Question

#include <iostream>
using namespace std;

struct From{
    int i;
    From(){}
};

struct By{
    By(const From& f){}
};

struct To{
    To(const By& b){}
};

int main() {
    From f;
    To to = f;  // error: conversion from 'From' to non-scalar type 'To' requested
    // By by = f;
    // To to = by;
    return 0;
}

有没有办法在不修改By和To的情况下完成这项工作？并且没有这样做：

 By by = f;
 To to = by;

Answer 1

只需在From中提供用户定义的转换运算符：

struct From
{
    int i;
    From(){}
    operator To() const
    {
         To to;
         //fill it
         return to;
    }
};

Answer 2

有没有办法在不修改By和To的情况下完成这项工作？

是。您可以为From提供转化运算符To()。这允许在单个用户定义的转化中将From转换为To：

struct From;
struct By;

struct To{
    To(const By& b){}
};

struct By{
    By(const From& f){}
};

struct From{
    int i;
    operator To() const { return To(By(*this)); }
    From(){}
};

Answer 3

我不保证它的实用性，但这个片段似乎可以做你想要的：

#include <iostream>
using namespace std;

struct From;

struct By{
    By(const From& f){}
};

struct From{
    int i;
    From(){}
    operator By() {}
};

struct To{
    To(const By& b){}
};

int main() {;
    From f;
    To to {f};  // error: conversion from 'From' to non-scalar type 'To' requested
    // By by = f;
    // To to = by;
    return 0;
}

我在From中声明了一个隐式转换运算符而没有触及By或To;重新安排声明来安抚编译器;并将初始化语法从＆＃34;更改为= f＆＃34;到＆＃34;到{f}＆＃34;。

请注意，这不可扩展，不能像这样一直应用;当编译器试图将您提供的部分组合在一起时，可以发生的转换数量和类型有限制。

编辑 ：正如我所指出的，唯一真正重要的变化是从复制初始化切换到直接初始化。我将按原样保留上面的代码，但在我的示例中不需要转换操作符。

隐式转换中的隐式参数

3 个答案: