C++多个接口只有不同的返回类型？

做一个以人类可读的方式将.NET IL翻译成C++的实验.

这是问题所在: C#允许您使用相同的方法名称来解析多个接口,这些接口的返回类型不同.C++似乎不支持这个,但是使用vTable解决两个接口是不可能的(或者我错了？).

我找到了一种使用模板在C++中复制C#方法的方法,但我想知道是否有一种方法不需要模板来解决同样的问题？模板很冗长,如果可能的话,我不希望它们用于每种接口类型.

这是C++版本.

template
class IMyInterface
{
    public: short (T::*Foo_IMyInterface)() = 0;
};

template
class IMyInterface2
{
    public: int (T::*Foo_IMyInterface2)() = 0;
};

class MyClass : public IMyInterface, public IMyInterface2
{
    public: MyClass()
    {
        Foo_IMyInterface = &MyClass::Foo;
        Foo_IMyInterface2 = &MyClass::IMyInterface2_Foo;
    }

    public: virtual short Foo()
    {
        return 1;
    }

    private: int IMyInterface2_Foo()
    {
        return 1;
    }
};

class MyClass2 : public MyClass
{
    public: virtual short Foo() override
    {
        return 2;
    }
};

void InvokeFoo(IMyInterface* k)
{
    (((MyClass*)k)->*k->Foo_IMyInterface)();
}

void main()
{
    auto a = new MyClass2();
    InvokeFoo(a);
}

这是C++基于的C#参考源.

interface IMyInterface
{
    short Foo();
}

interface IMyInterface2
{
    int Foo();
}

class MyClass : IMyInterface, IMyInterface2
{
    public virtual short Foo()
    {
        return 1;
    }

    int IMyInterface2.Foo()
    {
        return 1;
    }
}

class MyClass2 : MyClass
{
    public override short Foo()
    {
        return 2;
    }
}

namespace CSTest
{
    class Program
    {
        static void InvokeFoo(IMyInterface k)
        {
            k.Foo();
        }

        static void Main(string[] args)
        {
            var a = new MyClass2();
            InvokeFoo(a);
        }
    }
}

这个C++方法在下面不起作用,但希望它能做到(它更多的是我想要的).

class IMyInterface
{
    public: virtual short Foo() = 0;
};

class IMyInterface2
{
    public: virtual int Foo() = 0;
};

class MyClass : public IMyInterface, public IMyInterface2
{
    public: virtual short Foo()
    {
        return 1;
    }

    private: int IMyInterface2::Foo()// compiler error
    {
        return 1;
    }
};

class MyClass2 : public MyClass
{
    public: virtual short Foo() override
    {
        return 2;
    }
};

void InvokeFoo(IMyInterface* k)
{
    k->Foo();
}

void main()
{
    auto a = new MyClass2();
    InvokeFoo(a);
}

fstam.. 8

问题是你不能单独根据返回类型重载.

看到

Tutorialspoint

是否可以为重载方法使用不同的返回类型？

函数重载按返回类型？

最后一个stackoverflow线程指出可以使用运算符进行重载.

struct func {
    operator string() { return "1"; }
    operator int() { return 2; }
};

int main() {
    int x = func(); // calls int version
    string y = func(); // calls string version
    double d = func(); // calls int version
    cout <

你不能命名他们,这很快就会变成一团糟.

参数列表必须改变.Victor Padureau建议使用void返回类型并将值类型作为引用传递给方法中的值,这将起作用.您还可以使用更改不同类型的方法名称.   

class my_interface
{
public: 
    virtual short foo_short() = 0;
};

class my_interface2
{
public: 
    virtual int foo_int() = 0;
};

class my_class : public my_interface, public my_interface2
{
public: 
    short foo_short() override
    {
        return 1;
    }

    int foo_int() override
    {
        return 1;
    }
};

class my_class2 : public my_class
{
public: 
    virtual short foo_short() override
    {
        return 2;
    }
};

void InvokeFoo(my_interface* k)
{
    short result = k->foo_short();
    std::cout <

        

          
        

      

    

  

  
  

    

      

        小智..
         5
      
      
我有一个可行的解决方案.它并不完美,但如果您正在移植,它是一种解决问题的方法.

而不是调用int foo()你可以这样调用void foo(int& out)你将返回类型放在函数的调用部分.


1> fstam..：
问题是你不能单独根据返回类型重载. 

看到 


Tutorialspoint
是否可以为重载方法使用不同的返回类型？
函数重载按返回类型？


最后一个stackoverflow线程指出可以使用运算符进行重载. 

struct func {
    operator string() { return "1"; }
    operator int() { return 2; }
};

int main() {
    int x = func(); // calls int version
    string y = func(); // calls string version
    double d = func(); // calls int version
    cout <

你不能命名他们,这很快就会变成一团糟.

参数列表必须改变.Victor Padureau建议使用void返回类型并将值类型作为引用传递给方法中的值,这将起作用.您还可以使用更改不同类型的方法名称.   

class my_interface
{
public: 
    virtual short foo_short() = 0;
};

class my_interface2
{
public: 
    virtual int foo_int() = 0;
};

class my_class : public my_interface, public my_interface2
{
public: 
    short foo_short() override
    {
        return 1;
    }

    int foo_int() override
    {
        return 1;
    }
};

class my_class2 : public my_class
{
public: 
    virtual short foo_short() override
    {
        return 2;
    }
};

void InvokeFoo(my_interface* k)
{
    short result = k->foo_short();
    std::cout <

        

2> 小智..：
我有一个可行的解决方案.它并不完美,但如果您正在移植,它是一种解决问题的方法.

而不是调用int foo()你可以这样调用void foo(int& out)你将返回类型放在函数的调用部分.