C++，模板与自动与任何

Question

I'm working for my library, and i must generalize some functions, that is, these functions need to handle different types of data passed as parameters.

ex:

   Class myClass
   { 
     public:
       int num;
       char mark;
       vector <bool> boolVector;
   }

    myClass cl;

    void myFunction(any/auto/T value, int operation)
    {
      switch(operation)
      {
        case A:
        { 
           cl.num = value; break;
        } 
        
        case B:
        {
           cl.mark = value; break;
        }
        
        case C:
        {
          for(int i = 0; i < 10; i++)
          {
             cl.vector.at(i) = value[i];
          } 
          
          break;
        }
      }
    }

I'm undecided on what to use between:

• any,
• some
• template

obviously, this is a very trivial example, while the real functions in my code process this data more complicatedly

So:

1. who is the fastest?
2. Who uses the most memory?
3. Who is the most used?
4. Which do you prefer and why?

Answer 1

TL;DR You should probably re-think your design

None of auto , a template parameter, or std::any really work for your function as written.

In this context, auto and a template type parameter are the same thing.
That is

void foo(auto value)
{
    // ...
}

is just shorthand for

template <typename T>
void foo(T value)
{
    // ...
}

Since they're both templates, they are resolved at compile time. That is foo(some_int) and foo(some_char) end up calling different functions foo<int> and foo<char> that the compiler generates from the template that you wrote. As such, there's no runtime performance overhead (aside from possibly increased executable size). It also means the compiler can do type-checking to ensure you're not trying to do something with an object that it can't do. That means that whatever type is given as the parameter must be valid in all branches of the function; even if they'll never be taken for a given type of parameter at runtime.

---

std::any is something entirely different. std::any is a type-erased wrapper class that can hold objects of any type. Additionally, a given std::any object can change from holding one type to another over the course of its lifetime. That means that the compiler cannot do any type checking for you if you use std::any . Type checking can only be done at runtime, which means std::any is fairly cumbersome to use and has some runtime performance overhead. It has its uses, but they're fairly few and far between.

---

If you can, you should probably split your function into multiple. For instance:

void myFunctionA(int num)
{
    cl.num = num;
}

void myFunctionB(char mark)
{
    cl.mark = mark;
}

void myFunctionC(std::vector<bool> boolVector)
{
    cl.boolVector = boolVector;
}

(Note, be wary of std::vector<bool> , it isn't a real container and behaves strangely in some situations).