C++ 隐式转换的多参数

对于具有多个参数的构造函数

例如：

class C {
public:
    C(int a=1, int b=2){ cout << a << ", " << b << "\n"; }
}

int main(){
    C a(10), b = 20;
}

output:
10, 2
20, 2

C类{
公众：
C（inta=1，intb=2）{cout
或者，我必须始终为前面的参数赋值，然后才能使用后面的参数

是的。否则，编译器怎么知道哪个参数应该使用哪个参数呢

然而，实现这一点是有办法的。例如

struct C {
    enum { DefaultA = 1, DefaultB = 2 };
    C(int a = DefaultA, int b = DefaultB) { /* ... */ }
};

C object(C::DefaultA, 20);

或者，如果有许多参数具有不同的“默认值”：

或者，我必须始终为前面的参数赋值，然后才能使用后面的参数

是的。否则，编译器怎么知道哪个参数应该使用哪个参数呢

然而，实现这一点是有办法的。例如

struct C {
    enum { DefaultA = 1, DefaultB = 2 };
    C(int a = DefaultA, int b = DefaultB) { /* ... */ }
};

C object(C::DefaultA, 20);

或者，如果有许多参数具有不同的“默认值”：

C++不支持命名参数。必须指定第一个参数

此外，主函数中的变量名
b
与构造函数定义中的
b
是完全独立的。命名没有任何关系。
C++不支持命名参数。必须指定第一个参数

此外，主函数中的变量名
b
与构造函数定义中的
b
完全分离。命名没有任何关系。
通常在OOP中，每个对象实例都持有（并表示）一个状态。
因此，最好的方法是定义访问器函数，例如
void setB（int newBvalue）；
并以私人会员身份持有b

如果在同一对象的所有实例之间共享“B”，则考虑保存一个静态变量。
通常在OOP中，每个对象实例都持有（并表示）一个状态。
因此，最好的方法是定义访问器函数，例如
void setB（int newBvalue）；
并以私人会员身份持有b

如果在同一个对象的所有实例之间共享“B”，考虑保存一个静态变量。
 < P>我有同样的想法（也许你在那里找到了你更喜欢的东西）前一段时间，但就在现在，在阅读您的问题时，我想到了一种方法来真正实现这一点。但这是相当多的额外代码，所以问题仍然是它是否值得。我只是非常粗略地实现了它，我对我选择的名称并不感到自豪（我通常不使用
\uuu
，但已经很晚了）.无论如何，这就是你可以做到的：

#include <iostream>

struct C_members {
  int a;
  int b;
  C_members(int _a, int _b) : a(_a), b(_b) {}
};
class C_init {
  public:
    virtual C_members get(C_members init) const {
      return init;
    }
};
class C_a : public C_init {
  private:
    int a;
  public:
    C_a(int _a) : a(_a) {}
    C_members get(C_members init) const {
      init.a = a;
      return init;
    }
};
class C_b : public C_init {
  private:
    int b;
  public:
    C_b(int _b) : b(_b) {}
    C_members get(C_members init) const {
      init.b = b;
      return init;
    }
};
class C : private C_members {
  private:
    static const C_members def;
  public:
    C(C_init const& ai = C_init(), C_init const& bi = C_init()) : C_members(ai.get(bi.get(def)).a, bi.get(ai.get(def)).b) {
      std::cout << a << "," << b << std::endl;
    }
};

const C_members C::def(1,2); // default values

// usage:
int main() {
  C c1(C_b(77)); // 1,77
  C c2(C_a(12)); // 12,2
  C c3(C_b(5),C_a(6)); // 6,5
  return 0;
}

#包括
结构C_成员{
INTA；
int b；
C_成员（int_a，int_b）：a（_a），b（_b）{}
};
类C_init{
公众：
虚拟C_成员获取（C_成员初始化）常量{
返回init；
}
};
类别C_a：公共C_init{
私人：
INTA；
公众：
C_a（int_a）：a（_a）{}
C_成员获取（C_成员初始化）常量{
初始值a=a；
返回init；
}
};
C_b类：公共C_init{
私人：
int b；
公众：
C_b（int_b）：b（_b）{}
C_成员获取（C_成员初始化）常量{
初始b=b；
返回init；
}
};
C类：私人社区大学会员{
私人：
静态常量C_成员def；
公众：
C（C_init const&ai=C_init（），C_init const&bi=C_init（））：C_成员（ai.get（bi.get（def））.a，bi.get（ai.get（def））.b）{
std：：cout我也有同样的想法（--也许你在那里找到了你更喜欢的东西）前一段时间，但就在现在，在阅读您的问题时，我想到了一种方法来真正实现这一点。但这是相当多的额外代码，所以问题仍然是它是否值得。我只是非常粗略地实现了它，我对我选择的名称并不感到自豪（我通常不使用
\uuu
，但已经很晚了）.无论如何，这就是你可以做到的：

#include <iostream>

struct C_members {
  int a;
  int b;
  C_members(int _a, int _b) : a(_a), b(_b) {}
};
class C_init {
  public:
    virtual C_members get(C_members init) const {
      return init;
    }
};
class C_a : public C_init {
  private:
    int a;
  public:
    C_a(int _a) : a(_a) {}
    C_members get(C_members init) const {
      init.a = a;
      return init;
    }
};
class C_b : public C_init {
  private:
    int b;
  public:
    C_b(int _b) : b(_b) {}
    C_members get(C_members init) const {
      init.b = b;
      return init;
    }
};
class C : private C_members {
  private:
    static const C_members def;
  public:
    C(C_init const& ai = C_init(), C_init const& bi = C_init()) : C_members(ai.get(bi.get(def)).a, bi.get(ai.get(def)).b) {
      std::cout << a << "," << b << std::endl;
    }
};

const C_members C::def(1,2); // default values

// usage:
int main() {
  C c1(C_b(77)); // 1,77
  C c2(C_a(12)); // 12,2
  C c3(C_b(5),C_a(6)); // 6,5
  return 0;
}

#包括
结构C_成员{
INTA；
int b；
C_成员（int_a，int_b）：a（_a），b（_b）{}
};
类C_init{
公众：
虚拟C_成员获取（C_成员初始化）常量{
返回init；
}
};
类别C_a：公共C_init{
私人：
INTA；
公众：
C_a（int_a）：a（_a）{}
C_成员获取（C_成员初始化）常量{
初始值a=a；
返回init；
}
};
C_b类：公共C_init{
私人：
int b；
公众：
C_b（int_b）：b（_b）{}
C_成员获取（C_成员初始化）常量{
初始b=b；
返回init；
}
};
C类：私人社区大学会员{
私人：
静态常量C_成员def；
公众：
C（C_init const&ai=C_init（），C_init const&bi=C_init（））：C_成员（ai.get（bi.get（def））.a，bi.get（ai.get（def））.b）{
std：：cout在“C_a（int a）”中的“a（a）”：a（a）{}表示将“a”的值传递到C_成员中的变量“a”中吗？不，
a（a）
表示“获取参数
a
的值并用它构造我的成员
a
”。这就是通常对传递值进行初始化的方式（至少，我喜欢这样做。）我更改了一些变量名，因此情况更为明显。“C_a（int a）:a（a）{}”中的“a（a）”是否意味着将“a”的值传递到C_成员中的变量“a”中？不，
a（a）
意味着“获取参数的值
a
并用它构造我的成员
a
”。这就是通常对传递值进行初始化的方式（至少，我喜欢这样做）。我更改了一些变量名，因此发生的情况更为明显。