Question

说使用cast时，生成的对象是a是否正确？ const对象？

...因此只能用作函数的参数函数接受它作为const对象？

e.g。

class C1 {
    public: C1(int i=7, double d = 2.5){};
};

void f(C1& c) {};

int main(){
    f(8);
    return 1;
}
//won't compile

（当然，如果f（....）按值接收参数，那么它将得到一个非const版本它可以使用）

Answer 1

通常，当某种类型的对象转换为另一种类型的对象（非引用类型）时，会创建一个临时对象（而不是const对象）。临时对象（不可见，无名，右值）只能绑定（在C ++ 98/03中）为const的引用（临时称为“异常对象”除外）。因此，创建临时的转换结果只能用作函数的参数，该函数将其作为const引用接受，或者作为可以复制/转换为的类型。

所以，例如。

void f(double);  // 1
void f(const int&); // 2
void f(int&); // 3

struct B {  B(int) { } };
struct C { C(int)  { } };
void f(B b);  // 4
void f(B& b); // 5
void f(const C& c); //6
void f(C& c); // 7

// D inherits from B
struct D : B { D(int) : B(0) { } };
void f(D& d); // 8

int main()
{
   f( (int) 3.0 ); // calls 2, NOT 3
   f( (float) 3 ); // calls 1 - const reference requires the same type
   f( 1 );  // calls 2, NOT 3

   f( (B) 1 ); // calls 4, not 5 - can accept it by non-const value
   f( (C) 1 ); // calls 6, not 7 - can accept it by const-reference

   f( (D) 1 ); // calls 4, not 8 - since a 'D' temporary object can be converted to a 'B' object - but will not bind to a non-const reference
}

希望有所帮助。

Answer 2

将这个'铸造'称为有点偏差。你正在做'隐式建筑'。隐式构造总是会创建一个临时对象，而该对象又是const。

请注意，您可以将构造函数标记为“explicit”，这将阻止您在此处看到的隐式构造调用。但这只意味着你需要f（C（8））而不是f（8）; C实例仍然是const，因为它是临时的，但请注意没有执行转换。

如果您确实需要，请参阅const_cast了解脏的变通方法。另一种解决方法是做两个班轮：C c（8）; F（C）;

Answer 3

您可以将其重写为：

class C1
{
    public: C1(int i=7, double d = 2.5){};

};

void f(C1& c){};

int main()
{
    C1 c(8); //named
    f(c);
    //... can access the modified C1 instance here ...
    return 1;
}

编译器不喜欢你的版本是你的C1实例是一个未命名的临时实例：f将修改，但是（因为它是一个未命名的临时版）编译器知道调用者（main）无法接收/保留/注意这些修改。

使用c ++生成const对象

3 个答案: