C++ c++；使用新类型/类和友元重载构造函数

是否仍然可以使用

friend

将已声明的结构的构造函数重载为使用新定义的结构的构造函数。例如，在下面的简单示例中，我想用一个使用

struct B

，但不修改A.h的构造函数重载

struct A

构造函数

main.cpp

#include "A.h"
#include "B.h"

int main() {
    B x(2);
    A y(B); 
};

A.h

B.h

---

我知道我可以通过适当地放置

structb来解决这个问题和
A（B）在A.h中。我还想出了一种使用模板的方法，但这不是一个优雅的解决方案。它需要修改A.h。出于我不想进入这里的原因，我不想使用这两种技术中的任何一种。我想重载A:：A（）构造函数，而不修改A.h，更重要的是，不假设
#include“A.h”
的位置是可控的。我认为这就是friend的作用，但我不知道是否/如何让它与构造函数一起工作。
你不能重载不存在的东西。您也不能定义不存在的成员函数。但您可以编写一个简单的函数来完成这项工作：

A fromB(const B& s) { return A(s.b); }

如果允许修改
B
，则可以为其指定一个转换运算符：

struct B {
    explicit operator A() const { return A(b); }

    // as before
};

#include <iostream>
using namespace std;

struct A
{
    A(float val) : _val(val) {};
    float _val;
};

struct B{
    operator A(){ // how to make A from B.
        return A(2);
    }
};

int main() {
    B b;
    A a = b;
    cout << a._val << '\n';
    return 0;
}

你不能让不存在的东西过载。您也不能定义不存在的成员函数。但您可以编写一个简单的函数来完成这项工作：

A fromB(const B& s) { return A(s.b); }

如果允许修改
B
，则可以为其指定一个转换运算符：

struct B {
    explicit operator A() const { return A(b); }

    // as before
};

#include <iostream>
using namespace std;

struct A
{
    A(float val) : _val(val) {};
    float _val;
};

struct B{
    operator A(){ // how to make A from B.
        return A(2);
    }
};

int main() {
    B b;
    A a = b;
    cout << a._val << '\n';
    return 0;
}

不能向类中添加构造函数（或其他成员）。但是，您可以在涉及的其他类中创建转换运算符：

class B {
   // ...
public:
    explicit operator A() const { /* build an A object and return it */ }
};

不能向类中添加构造函数（或其他成员）。但是，您可以在涉及的其他类中创建转换运算符：

class B {
   // ...
public:
    explicit operator A() const { /* build an A object and return it */ }
};

如果您对
B
具有控制权，并且希望定义如何从
B
生成
a
的方法，则可以定义所谓的转换运算符：

struct B {
    explicit operator A() const { return A(b); }

    // as before
};

#include <iostream>
using namespace std;

struct A
{
    A(float val) : _val(val) {};
    float _val;
};

struct B{
    operator A(){ // how to make A from B.
        return A(2);
    }
};

int main() {
    B b;
    A a = b;
    cout << a._val << '\n';
    return 0;
}

#包括
使用名称空间std；
结构A
{
A（float val）：_val（val）{}；
浮动值；
};
结构B{
运算符A（）{//如何从B生成A。
返回A（2）；
}
};
int main（）{
B B；
A=b；
cout如果您对
B
有控制权，并且希望定义一种从
B
生成
a
的方法，您可以定义一个所谓的转换运算符：

struct B {
    explicit operator A() const { return A(b); }

    // as before
};

#include <iostream>
using namespace std;

struct A
{
    A(float val) : _val(val) {};
    float _val;
};

struct B{
    operator A(){ // how to make A from B.
        return A(2);
    }
};

int main() {
    B b;
    A a = b;
    cout << a._val << '\n';
    return 0;
}

#包括
使用名称空间std；
结构A
{
A（float val）：_val（val）{}；
浮动值；
};
结构B{
运算符A（）{//如何从B生成A。
返回A（2）；
}
};
int main（）{
B B；
A=b；
你在找吗？你在找吗？一个转换操作符不会做同样的事情吗？@0x499602D2是的，那可能是一个选项。就满足我想要的功能和优雅而言，转换操作符是一个不错的选择。一个转换操作符不会做同样的事情吗？@0x499602D2是的，那可能是一个选项。就满足我想要的乐趣而言功能性和优雅性，转换运算符是一种方法。您认为转换为
float
而不是
a
更合适吗，以便OP的示例可以使用构造函数
a（float）；
？@AndyG:conversion操作符可以根据需要构造
A
对象，包括使用
float
中的构造函数构建
A
，然后进行一些变异。如果需要非
显式
构造函数，直接转换为
A
也可以减少转换次数在一些转换序列中。我从未见过这个转换运算符，我也不确定它在功能上与构造函数有什么不同，但在我测试它时，它似乎完全按照我的需要工作，并且符合我的约束条件。谢谢。你认为转换为
float
比转换为
a
更合适吗OP的示例可以使用构造函数
A（float）；
？@AndyG:conversion操作符可以根据需要构造
A
对象，包括使用
float
中的构造函数构建
A
，然后进行一些变异。如果需要非
显式
构造函数，直接转换为
A
也可以减少转换次数在一些转换序列中。我从未见过这个转换运算符，我也不确定它在功能上与构造函数有什么不同，但在我测试它时，它似乎完全按照我的需要工作，并且符合我的约束条件。谢谢。