C++ 将模板生成的类分配给具有相同布局的C结构

如果我理解正确，对象“A”的定义如下：

typedef struct {
    int n;
    float *p;
} myStruct;
myStruct A;

是与对象“B”在内存中的布局完全相同的聚合，定义为：

template <typename T> class myTemplateClass
{
public:
    int n;
    T*  p;
};
myTemplateClass<float> B;

而不是不得不写作

A = *(reinterpret_cast< myStruct *>(&B));

A=*（重新解释cast（&B））；

每次

---

我问这个问题的原因是，我必须调用一个库函数，该函数公开了一个具有“myStruct”形式参数的接口，从代码中以myTemplateClass的形式保存数据要自然得多

根据类型参数，可以使

myTemplateClass

从正确的

myStruct

派生。您可以为此使用模板专门化：

template <typename T> class myTemplateClass;

// Specialization for float
template <> class myTemplateClass<float> : public myStruct {};

// Specialization for int
template <> class myTemplateClass<int> : public myOtherStruct {};

// And so on for other types...

模板类myTemplateClass；
//浮子专用化
模板类myTemplateClass:public myStruct{}；
//int的专门化
模板类myTemplateClass:公共myOtherStruct{}；
//等等，其他类型的。。。

---

这样，您可以将

myTemplateClass

的实例分配给

myStruct

，将

myTemplateClass

的实例分配给

myOtherStruct

。（好处：您不必依赖于“相同内存布局”猜测。）

您可以根据类型参数使

myTemplateClass

从正确的

myStruct

派生。您可以为此使用模板专门化：

template <typename T> class myTemplateClass;

// Specialization for float
template <> class myTemplateClass<float> : public myStruct {};

// Specialization for int
template <> class myTemplateClass<int> : public myOtherStruct {};

// And so on for other types...

模板类myTemplateClass；
//浮子专用化
模板类myTemplateClass:public myStruct{}；
//int的专门化
模板类myTemplateClass:公共myOtherStruct{}；
//等等，其他类型的。。。

---

这样，您可以将

myTemplateClass

的实例分配给

myStruct

，将

myTemplateClass

的实例分配给

myOtherStruct

。（好处：你不必依赖于“相同的内存布局”猜测。）

如果你从mystruct派生，那么，你可以对它使用静态转换。 如上所述，模板专门化也会起作用。 任何一天，我都会把静态的角色转换成重新解释的角色

下面是工作代码

typedef struct {
    int n;
    float *p;
} myStruct;
myStruct A;



template <typename T> class myTemplateClass:public myStruct
{
public:
    int n;
    T*  p;
};
//myTemplateClass<float> B;

typedef myTemplateClass<float> temp;


temp B;

int main()
{


    A = *(static_cast< myStruct *>(&B));

typedef结构{
int n；
浮动*p；
}我的结构；
我的结构A；
模板类myTemplateClass:public myStruct
{
公众：
int n；
T*p；
};
//MyTemplateB类；
typedef myTemplateClass温度；
温度B；
int main（）
{
A=*（静态_cast（&B））；

如果您从mystruct派生，那么您可以对其使用静态强制转换。 如上所述，模板专门化也会起作用。 任何一天，我都会把静态的角色转换成重新解释的角色

下面是工作代码

typedef struct {
    int n;
    float *p;
} myStruct;
myStruct A;



template <typename T> class myTemplateClass:public myStruct
{
public:
    int n;
    T*  p;
};
//myTemplateClass<float> B;

typedef myTemplateClass<float> temp;


temp B;

int main()
{


    A = *(static_cast< myStruct *>(&B));

typedef结构{
int n；
浮动*p；
}我的结构；
我的结构A；
模板类myTemplateClass:public myStruct
{
公众：
int n；
T*p；
};
//MyTemplateB类；
typedef myTemplateClass温度；
温度B；
int main（）
{
A=*（静态_cast（&B））；

这需要一些样板文件。每个myStruct有两个函数，每个

模板有两个函数

在
myStruct
的命名空间中，插入以下两个函数：

auto members( myStruct& s ) {
  return std::tie(s.n, s.p);
}
auto members( myStruct const& s ) {
  return std::tie(s.n, s.p);
}

在C++11中，必须添加一个
decltype
子句来显式地给出返回值。基本上
tie
按照声明的确切顺序排列成员

在
myTemplateClass
的主体中，声明一个执行类似操作的
friend
函数
members
：

template <typename T>
class myTemplateClass {
public:
  int n;
  T*  p;
  friend auto members( myTemplateClass<T>& self ) {
    return std::tie( self.n, self.p );
  }
  friend auto members( myTemplateClass<T> const& self ) {
    return std::tie( self.n, self.p );
  }
};    

它还进行测试，以确定转换为的类型是否支持
成员
。您可以更进一步，测试
成员
返回值是否可以从
成员的返回值（*此）
，但这会增加更多的样板文件。
这需要一些样板文件。每个
myStruct
有两个函数，每个
模板有两个函数

在
myStruct
的命名空间中，插入以下两个函数：

auto members( myStruct& s ) {
  return std::tie(s.n, s.p);
}
auto members( myStruct const& s ) {
  return std::tie(s.n, s.p);
}

在C++11中，必须添加一个
decltype
子句来显式地给出返回值。基本上
tie
按照声明的确切顺序排列成员

在
myTemplateClass
的主体中，声明一个执行类似操作的
friend
函数
members
：

template <typename T>
class myTemplateClass {
public:
  int n;
  T*  p;
  friend auto members( myTemplateClass<T>& self ) {
    return std::tie( self.n, self.p );
  }
  friend auto members( myTemplateClass<T> const& self ) {
    return std::tie( self.n, self.p );
  }
};    

它还进行测试，以确定转换为的类型是否支持
成员
。您可以更进一步，测试
成员
返回值是否可以从
成员的返回值（*此）< />代码，但这会增加更多的模板。< /p>你可以修改两个类吗？如果是，你不想在C++中使用TyPufFrEST结构。但是，如果你有一个C接口，那么给B转换操作器可能有模板化的转换功能，专门用于<代码>浮点< /C> >和<代码> MyStult，它转换成正确的结构。你有多少个<代码> MyStReult>代码>结构？这样的代码>结构> <代码> s，多个位是一个性能瓶颈？多少个<代码> MyTeMePraceCass<代码>模板？你编译的C++版本是什么？C++ 03、C++ 11或C++ 14？哪个编译器和版本？至少可以使用
std:：memcpy（&A，&B，sizeof（A））如果你有一个C++接口，那么如果你有一个C接口，那么给B转换操作器可能有一个模板化的转换函数，它有一个专门化的代码>浮点< /COD>和<代码> MyStult，它转换成CORR。ECT结构？有多少个<代码> MyStReult>代码>类型的结构？这样的代码>结构> <代码> s，是否不止一次地复制了性能瓶颈？有多少个<代码> MyTimePraceCass<代码>模板？你编译的C++版本是什么？C++ 03、C++ 11或C++ 14？哪个编译器和版本？无论哪种类型，您至少可以使用
std:：memcpy（&A，&B，sizeof（A））；
，这样您就不会违反str