C# c++；铸造过载当量 我想知道C++中是否有可能实现与C实例中相同的抛出重载： 在C++中应该是这样的： #include <string> using namespace std; class A{ /*SOME CAST OVERLOADING GOES HERE*/ }; void main(){ A a = "hello"; A b = 5.0; } #包括 使用名称空间std； 甲级{ /*这里有一些CAST重载*/ }; void main（）{ A=“你好”； A b=5.0； }

您能帮助我如何使此强制转换重载吗？

这通常是通过构造函数实现的：

用法：

A（“你好”）、b（4.2）、c=3.5、d=std:：string（“世界”）

（如果声明构造函数
explicit
，则只允许使用第一种形式（“直接初始化”，带括号）。否则，两种形式完全相同。）

单参数构造函数也被称为“转换构造函数”，原因就在于：您可以使用它从其他对象构造对象，即“转换”A
double
，例如，转换为
A

隐式转换被广泛使用。例如，它将应用于以下情况：

void f(A, const A&) { /* ... */ }

int main() { f(1.5, std::string("hello")); }

这将构造临时变量
A（1.5）
和
A（“hello”）
，并将它们传递给
f
。（如第二个参数所示，临时变量也绑定到常量引用。）

更新：（归功于@cHao的查找。）根据标准（12.3.4），“最多一个用户定义的转换（构造函数或转换函数）隐式应用于单个值。”（这是指隐式转换；直接初始化a la
a（“hello”）；
不属于此*。请参阅。）所以不幸的是你不能说“你好”，“世界”）。（当然，您可以添加
constchar*
构造函数，在新的C++11中，您甚至可以毫不费力地将其转发到字符串构造函数。）

*)我认为这实际上有点微妙。只有用户定义的转换受规则影响。因此，首先，您可以免费获得从
char（&）[6]
到
const char*
的基本转换。然后得到一个从
constchar*
到
std:：string
的隐式转换。最后，您有一个从
std:：string
到
A
的显式转换结构。您可以为构造函数提供所需类型的一个参数：

class Foo {

  int bar;

public:
  Foo(const int bar) : bar(bar) {};

}

Foo foo = 5;

没有必要铸造。。。这可以很容易地通过为类创建构造函数来实现，这些构造函数采用正确的参数类型，并且只使用一个参数，这样编译器就可以隐式地调用它们

如果构造函数接受多个非默认参数，则不能在转换操作中使用它们

此外，如果您希望避免在基于推断类型转换的构造函数选择中出现歧义，则始终可以对构造函数使用
explicit
关键字。例如，想象这样一个场景：

 struct test
 {
     int a;

     test (signed int b): a(b) {}
     test (unsigned int b): a(b) {}
 };

 int main()
 {
     test A = 5.0;

     return 0;
 }

这将导致编译器错误，因为将
double
类型转换为scaler类型时存在歧义。。。
double
类型可以隐式转换为这两种类型。这可以通过使用
explicit
关键字进行以下操作来解决：

struct test
{
    int a;

    test (signed int b): a(b) {}
    explicit test (unsigned int b): a(b) {}
};

现在，只有通过了
无符号int
的
测试
的构造函数版本才会被调用。从
double
类型的转换操作将使用默认的
int
版本，从而消除歧义问题。
转换运算符将提供从您的类型到其他类型的隐式转换。例如：

class A
{
public:
  operator std::string () const { return "foo"; }
};

但是，可以使用隐式转换，因为当您不希望使用隐式转换并且希望编译器出错时，可以使用隐式转换。因此，通常最好在目标对象上实现转换构造函数，而不是在源对象上实现转换运算符

class A
{ 
public:
  A(const std::string& rhs) { /* ... */ }
};

但是，仍然有一些隐式转换。考虑：

string f = "foo";
A foo = f;

f
隐式转换为
A
，因为convert构造函数可用。不过，这可能会导致编译器错误。通过标记convert构造函数
explicit
，可以轻松地将其从一种类型转换为另一种类型，但只能在您真正想要的时候进行转换

#include <string>

using namespace std;

class A
{
public:
    A() {};
    explicit A(const std::string& ) {};
};

int main()
{
    string f = "foof";
    A a1 = f;   // WONT COMPILE
    A a(f);     // WILL COMPILE
}

#包括
使用名称空间std；
甲级
{
公众：
A（）{}；
显式A（const std:：string&）{}；
};
int main（）
{
字符串f=“foof”；
a1=f；//不会编译
A（f）；//将编译
}
它在C#中的意思是什么？
在C#中，语义不是重载
操作符=
（您不能重载），而是提供从任何类型到类型a或从类型a到任何类型的强制转换操作符

这意味着以下代码（通过A到类型转换完成）：

用于赋值，可以是简单赋值（如C行和D行），也可以是声明赋值（如A行和B行）。行E和F演示了如何将用户类型转换为其他类型

如何在C++中实现？
<>在C++中，行A和B是对象构造，将调用相关构造函数。
行C和D是赋值，它将调用相关赋值运算符

因此，您提供的C++代码必须提供字符串和双份的构造函数和赋值，如下：

class A
{
    public:
        A(const std::string & s) { /*...*/ }
        A(double d)              { /*...*/ }

        A & operator = (const std::string & s) { /*...*/ ; return *this ; }
        A & operator = (double d)              { /*...*/ ; return *this ; }

        // etc.
} ;

这样，你就可以

void main()
{
    A a0 = "Hello" ;   // constructor
    A a1("Hello") ;    // constructor
    A a2 = 5.0 ;       // constructor
    A a3(5.0) ;        // constructor


    a0 = "Hello World" ; // assignment
    a0 = 3.14 ;          // assignment
}

C++中的CAST运算符呢？
 C++中的CAST操作符像下面的C→转换器操作符一样工作：
class A
{
    static public operator string(A a)   { /*... ; return a string */ }
    static public operator double(A a)   { /*... ; return a double */ }

        // etc.
}

在C++中，CAST运算符是这样写的：

class A
{
    public:
        operator std::string()   { /*... ; return a string */ }
        operator double()        { /*... ; return a double */ }

        // etc.
} ;

void main()
{
    A a ;
    std::string s ;
    double d ;

    // etc.

    s = a ;    // cast operator
    d = a ;    // cast operator
}

为什么C++如此复杂？
在C#中，可以将强制转换/转换运算符从类类型写入任何类型，或从任何类型写入类类型

在C++中，对于转换，必须在一种或多种方式之间进行选择，即：构造函数、赋值操作符或CAST运算符，因为在C++中，对类型和操作有细粒度的控制，
void main()
{
    A a0 = "Hello" ;   // constructor
    A a1("Hello") ;    // constructor
    A a2 = 5.0 ;       // constructor
    A a3(5.0) ;        // constructor


    a0 = "Hello World" ; // assignment
    a0 = 3.14 ;          // assignment
}

class A
{
    static public operator string(A a)   { /*... ; return a string */ }
    static public operator double(A a)   { /*... ; return a double */ }

        // etc.
}

class A
{
    public:
        operator std::string()   { /*... ; return a string */ }
        operator double()        { /*... ; return a double */ }

        // etc.
} ;

void main()
{
    A a ;
    std::string s ;
    double d ;

    // etc.

    s = a ;    // cast operator
    d = a ;    // cast operator
}