C++ C++；分离数据与逻辑

我之所以希望以这种方式分离，是因为数据是从无到有的，方法可以有数百个依赖项。所有依赖于数据的人都不应该依赖于方法依赖性

我想做一些类似的事情：

//s_class_name.h
struct structName
{
    data m_data
}

---

---

static_cast（&structNameObject）->方法（arg1、arg2、arg3、…、argN）；

我发现有两个问题：

1） 打开对数据的所有访问。我想向所有使用struct而不是class操作的人开放数据

2） 静态下传未定义

你能给我解释一下，如何更好地实现模式数据和逻辑分离吗

UPD：我有另一个想法，但我无法解释为什么它不好：

1） 在s_class_name.h中，我可以声明模板方法
2） 在class_name.h中，我可以实例化模板参数。

设计的可能实现： 避免未经授权访问数据表单的一种方法是保护数据：只有从数据结构继承的类才能访问它：

 class structName
 {
 protected:  // only classes inheriting from this structure can access the data
    data m_data;
 };

然后，从数据结构继承的类可以根据需要使用数据：

class className : public structName
{
public:
    void method(int arg1) { //using m_data
        for (int i = 0; i < arg1; i++)
            cout << i << ":" << m_data << endl; 
    }
};

以下是一些可能的用途：

structName d; 
className cn(&d);        // creating an object 
cn.method(10);           // using methods on the data 
className(&d).method(3); // throw away temporary object destroyed when expression is evaluated. 
                         // so no need for down-casting anymore.  

---

通过这种设计，可以消除弱点1、4和6。这种方法非常理想，例如，如果您的结构数据是按需从数据库上传的

迪特·吕克，对不起。修正了“我想向所有使用struct操作的类开放数据，但不向类开放数据”的问题。你是说你想向所有使用该数据的类开放数据，并且希望这些数据对类的用户隐藏？我的观点是：逻辑或行为不能用对象（理智地）表达。我的意思是，我想向所有使用该结构操作的人打开该结构的文件。但我想对所有使用该类操作的人隐藏它。“我的意思是，我想向所有使用该结构操作的人打开该结构的文件。但我想对所有使用该类操作的人隐藏它。”我不能对此感到沮丧，因为从形式上讲，如果你想对所有使用该类操作的人隐藏它，你应该去私人继承处。但是再也没有悲观情绪了。另一种方法是使用组合而不是继承（根据

className

不是真正的

structName

，但实际上已经-a

structName

）的原则，@pvl I添加了一个部分，建议使用组合改进设计。Thx！但我完全不明白-类对象是数据，所以

structNameObject

和

classNameObject

是相同类型的对象。为什么没有琐碎的转换（为什么在“数据类”和“函数类”之间没有等价关系（不是内在性）？

class className : public structName
{
public:
    void method(int arg1) { //using m_data
        for (int i = 0; i < arg1; i++)
            cout << i << ":" << m_data << endl; 
    }
};

className c;    // if your object was a class before 
structName*d=&c; 
static_cast<className *>(d)->method(10);  // you can downcast
               // if your object wasn't a class before, it's UB, but it could probably work if your class has not virtuals and no own data. 

struct structName { data m_data; };

class className {
private: 
    structName *data;   // access to your data object 
public:
    className(structName *d) : data(d) {}  // constructor 
    void method(int arg1) { //using m_data
            cout << data->m_data << endl; 
    }
};

structName d; 
className cn(&d);        // creating an object 
cn.method(10);           // using methods on the data 
className(&d).method(3); // throw away temporary object destroyed when expression is evaluated. 
                         // so no need for down-casting anymore.