c型结构的安全动态浇注？ 我有一些C++结构，它们是通过一些连接C++部分的算法来使用的。 输入端有一个C++结构，继承了C结构，添加了一些成员。在输出端，有些组件也可能需要这些数据 是否有一种安全的方法来检测这个C结构是否是C++的类？也许通过使C++类子类多态和使用动态转换来实现？ struct Cstruct{ int someData; }; class CPPclass: public Cstruct{ CPPclass(){}; int someMoreData; };

所以可能是

class CPPclass: public Cstruct{
  virtual ~CPPclass(){};
  CPPclass(){};
  int someMoreData;
};

void test(Cstruct* i_c){
  auto cpp = dynamic_cast<CPPclass*>(i_c);   // < does not work, because Cstruct is not polymorphic
  if(cpp){
      // da;
  }
}

class-CPPclass:public-Cstruct{
虚拟~CPPclass（）{}；
CPPclass（）{}；
int-someMoreData；
};
无效测试（Cstruct*i_c）{
auto cpp=dynamic_cast（i_c）；//<不起作用，因为Cstruct不是多态的
如果（cpp）{
//da；
}
}

但也许吧

class CPPclassHelper: public Cstruct{
  virtual ~CPPclassHelper(){};
  CPPclassHelper(){};
  int someMoreData;
};

class CPPclass: public CPPclassHelper{
  virtual ~CPPclassHelper(){};
};

void test(Cstruct* i_c){
  auto cpph = static_cast<CPPclassHelper*>(i_c); 
  auto cpp = dynamic_cast<CPPclass*>(cpph );   
  if(cpp){
      // da;
  }
}

类CPPclassHelper:公共Cstruct{
虚拟~CPPclassHelper（）{}；
CPPclassHelper（）{}；
int-someMoreData；
};
类CPPclass:公共CPPclassHelper{
虚拟~CPPclassHelper（）{}；
};
无效测试（Cstruct*i_c）{
自动cpph=静态浇铸（i\U c）；
自动cpp=动态投影（cpph）；
如果（cpp）{
//da；
}
}

您可以自己维护类型信息。使用一组指向

Cstruct

的静态指针，这些指针是

CPPclass

的基础。在

CPPclass

的所有构造函数中插入基，并在析构函数中删除。然后，可以使用对该集合的查找来实现安全强制转换

以下是一个例子：

struct CPPclass: Cstruct{
    CPPclass(){
        bases.insert(this);
    };
    CPPclass(const CPPclass&){
        bases.insert(this);
    };
    CPPclass(CPPclass&&){
        bases.insert(this);
    };
    ~CPPclass(){
        bases.erase(this);
    };

    static CPPclass* safe_cast(Cstruct* c) {
        auto it = bases.find(c);
        return it == bases.end()
            ? nullptr
            : static_cast<CPPclass*>(*it);
    }

private:
    static std::unordered_set<Cstruct*> bases;
};

struct CPPclass:Cstruct{
CPPclass（）{
基础。插入（本）；
};
CPPclass（常数CPPclass&）{
基础。插入（本）；
};
CPPclass（CPPclass&&）{
基础。插入（本）；
};
~cppglass（）{
删除（这个）；
};
静态CPP类*safe_铸件（Cstruct*c）{
自动it=bases.find（c）；
返回它==bases.end（）
？空PTR
：静态投影（*it）；
}
私人：
静态标准：：无序的集合基；
};

用法：

int main() {
    CPPclass cpp;
    Cstruct  c;

    Cstruct* ptr_cpp = &cpp;
    Cstruct* ptr_c   = &c;

    std::cout << CPPclass::safe_cast(ptr_cpp) << '\n'; // some address equal to &cpp
    std::cout << CPPclass::safe_cast(ptr_c)   << '\n'; // null
}

intmain（）{
类cpp；
c结构c；
Cstruct*ptr_cpp=&cpp；
Cstruct*ptr_c=&c；
当你说“C-structure”时，你指的是一个声明了
extern“C”的结构
并在某些现有的C库或接口中使用，对吗？出于兼容性原因，这不能更改？如果我理解正确，您需要将
Cstruct
编译为C代码，但您希望稍后能够确定
Cstruct*
是否实际使用
dynamic之类的东西指向
CPPclass
对象_cast
？@无用的
extern“C”
对结构定义没有任何影响。它只影响函数的调用约定，但这并不能回答问题。你说的“C”是什么意思在C++中，它是与规则<代码>结构>代码相同的吗？你必须用C代码来共享它吗？它是由外部C接口拥有的，或者你能改变它吗？一个“C结构”（又名为“代码>外部””C“< /代码>”不能多态使用，因此指向某个对象的指针不能在
动态\u cast
中使用。唯一的方法是“C结构”包含一些代码可以检查的数据（例如，标志、无效指针）。程序员有责任适当地使用这些数据，也就是说，根据各种定义，这些数据并不“安全”