Question

更改类中的类/结构值对我来说是一个谜。我今天尝试做了一些研究，并提出了以下解决方案。我想知道这是否是一个函数改变类内部东西的正确方法。是否有必要以指针方式完成此操作？有没有更合适的方法来实现这一目标？

#include <iostream>

int main()
{

class Someclass {
    private:
    int Integer;

    public:

    Someclass(int i):
    Integer(i){} //CTOR

    struct Somestruct { 
        int a, b;
    };
    Somestruct Mystruct;

    void func(){
        Mystruct.a = Integer/2;
        Mystruct.b = Integer*2;
    };
};

Someclass A(10);
A.func();
std::cout << A.Mystruct.a << " " << A.Mystruct.b << std::endl;
}

我编写此代码的原因是因为我想解析一个文件，从“Integer”行开始到一个自定义的结构“Mystruct”，这个类应该以某种方式传递给我。这是编写此类代码的可接受方式吗？

Answer 1

这是你正在寻找的吗？我对自己的理解不太自信。

template <int I>
struct Someclass;

template <>
struct Someclass<1>
{
    int Integer = 1;
    int a, b;

    void func()
    {
        a = Integer/2;
        b = Integer*2;
    }
};

template <>
struct Someclass<2>
{
    int Integer = 2;
    int a, b, c;

    void func()
    {
        a = Integer/2;
        b = Integer*2;
        c = Integer*Integer;
    }
};

int main()
{
    Someclass<1> A;
    A.func();
    std::cout << A.a << " " << A.b << std::endl;

    Someclass<2> B;
    B.func();
    std::cout << B.a << " " << B.b << " " << B.c << std::endl;

    return 0;
}

Answer 2

我理解你的问题是关于封装，理解内部结构是数据持有者，外部类必须以某种方式管理它。

您设计的弱点

在您的设计中，Mystruct是公开的。因此Someclass以外的任何内容都可以访问数据，但也可以更改数据。这很容易出错，因为无法保证外部代码不会破坏结构的某些不变量。

改进方法

最干净的事情当然是让一些getter和setter访问数据。但是有30个成员，这是很多代码。

如果您的构建过程初始化了结构的数据，则第二种方法可能是将外部访问限制为只读。你可以通过使Mystruct私有并提供一个返回const引用的函数来实现这一点：

class Someclass {
    Somestruct Mystruct; 
public: 
    ...
    const Somestruct& get() { return Mystruct; }
};

std::cout << A.get().a << " " << A.get().b << std::endl;

Online demo

然而，在进入这个方向之前，我会检查是否无法封装对结构原始数据的访问，例如通过提供管理数据的功能而无需了解内部结构：

class Somestruct {
    ...
public:
    ostream& show_simplified_specs(ostream& os) {
        os << a << " " << b;
    }
}

第三种方法可以是使用builder design pattern基于Someclass和其他部分来封装Somestruct的构建过程。

指针？

如果可能，应该避免使用指针。例如，假设您有一个Someclass向量来将所有这些类保留在内存中。在某个时刻，您会得到一个指向元素Mystruct的指针。假设您然后向向量添加一个新项：所有先前的指针都可能无效。

参考文献可能存在同样的风险。但我认为虽然缓存函数返回的指针是一种常见的习惯用法，但实际上复制函数返回的引用并不常见。

更改类内的结构或类有或没有指针

2 个答案: