自动调用原始指针的自定义转换器 A* <-> B*

automatic calling custom converter of raw pointers A* <-> B*

本文关键字：lt gt 转换器 调用 原始 指针 自定义      更新时间：2023-10-16

是否可以在不同类型的原始指针A*和B*之间定义自定义转换器(converter1<T>和converter2)，
然后将所有函数(fa()和fb())放在某一个类中
使用适当的转换器(converter1<T>或converter2)?

简而言之，我希望程序使用自定义函数将A*转换为B*，反之亦然。
我希望它能自动完成，方便我。

class Manager{
    void fb(B* b){ /** something complex       */ }
    void fa(A* a){ /** different thing complex */ }
    void testCase(){
        A* a=   ... ;  
        fa(a);  
        fb(a);  //automatic convert to B* using "converter2" (wish)
        B* b=   ... ;
        fa(b);  //automatic convert to A* using "converter1" (wish)
        fb(b);
    }
    template<class T> T* converter1(B* b){  //hardcoded, non-static.
        return this->getId<T>(b);   
        //^^^ just an example to show how custom it is,
        //    currently T=A
    }
    B* converter2(A* a){  //hardcoded
        return a->getB();   
        //^^^ just an example to show how custom it is.
    }
}

实际案例中有多个A - A1、A2、A3等。
A和B不是相互派生的

我希望有办法。我考虑的是指针的构造函数

不，这是不可能的

指针是内置类型，并且只存在内置类型之间的内置转换。用户定义的转换只适用于用户定义的类类型。

你可能需要切换到你自己品牌的智能指针来处理这个

通过引用(或智能指针)更有可能:

struct A {};
struct B {};

A& convert_to_a(A& a) { return a; }
A convert_to_a(B const& b) { 
    // makes a new A from a B
    return A(); 
}
B& convert_to_b(B& b) { return b; }
B convert_to_b(A const& a) { return B(); }

struct Manager
{
  template<class T>
  void fa(T&& t) { 
    auto&& a = convert_to_a(t); 
    // do something with a
    (void)a;
  }
  template<class T>
    void fb(T&& t) { 
    auto&& b = convert_to_b(t); 
    // do something with b
    (void)b;
  }
};
int main()
{
  A a;
  B b;
  Manager m;
  m.fa(a);
  m.fb(a);
  m.fa(b);
  m.fb(b); 
}

这不是你想要的方式。
无论如何，你可以使用一个全捕获函数和一些特征来模拟它。
它遵循一个最小的工作示例:

#include<iostream>
struct A {};
struct B {};
template<typename T>
A* ToAConverter(T*) = delete;
template<>
A* ToAConverter<B>(B *b) {
    // just an example
    return new A;
}
struct Manager{
    void fa(A* a){ std::cout << "fa" << std::endl; }
    template<typename T>
    void fa(T *t) {
        std::cout << "convert and forward" << std::endl;
        fa(ToAConverter<T>(t));
    }
    void testCase(){
        A *a = new A;  
        fa(a);  
        B *b = new B;
        fa(b); 
    }
};
int main() {
    Manager m;
    m.testCase();
}

如果没有为特定类型定义converter，则会收到编译时错误。
如您所见，当您调用fa时，您不再需要显式地调用转换器。

相关文章：