构造函数调用问题

Question

在此代码中尝试创建 dobj4 时出现编译器错误

#include<iostream>
using namespace std;
class mod;
class  name {
    friend mod;
    public:
            name(const char* n) {
                    cout << "1 arg constructor for name\n";
            }
            name() {
                    cout << "no arg constructor for name\n";
            }
            name(const char* n, int i ){
                    cout << "2 arg constructor for name\n";
            }
      };

class mod {
    public:
    mod() {
            cout << "base class constructor invoked\n";
    }
};

struct derived : mod {

    derived(name) {
            cout << "derived constructor invoked\n";
    }
 };

int main() {
    name nobj;
    derived dobj(nobj);

    name nobj1("hello");
    derived dobj1(nobj1);

    derived dobj2("Hi");

    name nobj2("yo", 2);
    derived dobj3(nobj2);

 //      derived dobj4("go", 4);

    return 0;
}

需要了解在 dobj2 的情况下传递字符串时如何调用名称的构造函数，但在 dobj4 的情况下会导致错误。 如何解决这个问题？

Answer 1

我觉得你的问题可能会更短更容易理解示例代码：（我还修复了它以使其可编译）

即使继承在这里没有相关性，我也留下了派生名称，并且我已将其删除为不重要

#include<iostream>
class  name {
public:
    name() {
        std::cout << "no arg constructor for name\n";
    }
    name(const char* n) {
        std::cout << "1 arg(" << n <<") constructor for name\n";
    }
    name(const char* n, int i ) {
        std::cout << "2 arg(" << n << ',' << i <<") constructor for name\n";
    }
};
struct derived {

    derived(const name& n ) {
        std::cout << "derived name constructor invoked\n";
        (void)n;
    }
};

int main() {

    name nobj;
    derived dobj(nobj);

    derived dobj2("Hi");

    derived dobj4({"go", 4}); //see the initialization list instead of 2 parameters passing

    return 0;
}

Answer 2

C++03 和C++11 的构造函数转换规则各不相同。

在C++03 中：只有一个参数的构造函数，或者在有多个参数的情况下，其余参数具有默认值 是隐式可转换的。

例子：

name(const char* n) {}
name(int n, int i = 0) {} // i has a default value

在C++11：上面C++03 中定义的所有情况以及具有多个参数的构造函数。但是这样的构造函数调用需要大括号初始化。

例子：

derived dobj4({"go", 4}); // call to name(const char* n, int i) is brace-initialized

不用说，如果构造函数被声明为explicit，它就不会被转换。