如何使用两个构造函数？

Question

我有这样的代码。

#include <iostream>
#include <vector>

using namespace std;

class AbstractValueC{
        private:
                long age = 0;
                int abs;
                bool spec = false;
        public:
                AbstractValueC() {
                        abs = 0;
                }
                AbstractValueC(int& a, bool b = false){
                        abs = *a;
                        spec = b;
                }
                AbstractValueC(int a, bool b = false){
                        abs = a;
                        spec = b;
                }
                int get_value() const {
                        return abs;
                }
                long get_age(){
                       return age;
                }
 };

int main(){
    vector<AbstractValueC> v;
    int init = 1;
    int next = 2;
    v.push_back(AbstractValueC(std::move(init)));
    cout << "I have created first v element." << endl;
    v.push_back(AbstractValueC(std::move(next)));
    cout << "I have created second v element." << endl;

    std::vector<AbstractValueC> result;
      for (auto a : v) {
          int pre = a.get_value();
          result.push_back(AbstractValueC(pre));
        }
    cout << "I have created result." << endl;

    return 0;
}

请告诉我如何解决

的错误

invalid type argument of unary ‘*’ (have ‘int’)
                         abs = *a;
                                ^

和错误

call of overloaded ‘AbstractValueC(int&)’ is ambiguous
           result.push_back(AbstractValueC(pre));
                                              ^

在我的实际代码中，我实际上为Abs成员使用了一个自定义类型（int）来代替abs。此外，还要求我不能在main中调用Abs的默认构造函数。我可以使用abs = Abs::null;。因此，请提出一个解决方案，如果在类定义中将Abs替换为int，请避免调用Abs的默认构造函数。

Answer 1

一元“ *”（具有“ int”）的无效类型参数

AbstractValueC(int& a, bool b = false){
                        abs = *a;
                        spec = b;
                }

参数a是一个int引用，而不是一个指针，因此您不能取消引用为*a。

代码应为abs = a;

对重载的“ AbstractValueC（int＆）”的调用含糊不清

正如@strom在评论中指出的那样，您有2个类似的构造函数：

AbstractValueC(int& a, bool b = false)
AbstractValueC(int a, bool b = false)

哪个编译器无法轻易区分。您应该摆脱其中之一。

Answer 2

真正的问题是您正在使用具有相同签名的两个构造函数：

编译器如何在使用之间进行选择：

AbstractValueC v=AbstractValueC(value);//int constructor

和

AbstractValueC v=AbstractValueC(value);//reference constructor

有空

Int value = 0;//for example

要摆脱此错误（模棱两可的构造函数调用），您可以更改一个构造函数或将指针构造函数替换为指针构造函数

要将构造函数更改为指针，您需要在类中创建一个值指针并创建一个构造函数：

// in class declaration
Int *pointerValue = nullptr;

AbstractValueC(int* pointer, bool b = false);

// implementation
AbstractValueC::AbstractValueC(Int *pointer, bool b=false) {
    pointerValue=pointer;
}