常规/动态类型作为参数C / C ++

Question

I would like to achieve something like this:

class Test {
    Test() {}
    Test(generalObject a){
       // do something
    }
}

int main(){
    Test a = 5;
    Test b = "A";
    Test c = true;
}

Is this even possible with the solution I would like?

generalObject can be any other type as well, doesn't need to be class type. Of course I know that I can write like different operator for different type, but I would like to skip that phase.

Answer 1

These:

Test a = 5;
Test b = "A";
Test c = true;
Test d = Test();

are not assignments, they are copy initializations . Compiler looks for a non-explicit constructor (including copy constructor for the last statement). operator= is not needed in your code.

As you're not doing anything with the passed arguments, this comes up (only to get your code to compile):

struct Test {
    Test() = default;

    template <typename T> // a constructor template
    Test(T const&) {}
};

C++ does not have a base class for every type, you need to use constructor template to instantiate a constructor for every type that's required - at compile time.

---

This gets more complicated if you actually want to store the argument inside Test (template specializations for array types, convenience function template make_test , etc...). I guess this is your entry to templates, so you might want to go step by step.

Answer 2

In you example you dont need assignment operator, but converting constructor which will accept various types:

class Test{
public:    
    Test(){}

    Test(int r){}
    Test(const char* r){}
    Test(bool r){}
    Test(const Test& r){}
};
int main(){
    Test a = 5;
    Test b = "A";
    Test c = true;
    Test d = Test();
}

But it makes sense to implement also assignment operator. If you really need any type then use templates, your constructor will look like below:

    template<typename T>
    Test(const T& t){}