Question

我目前正在将C代码重写为C ++代码。在执行此操作时，我将structs替换为classes。这意味着一些变量从公共变为私有。现在在转换阶段，我想通过有时编译程序并运行它来进行一些错误检查。因此，我打算同时拥有公共和私有变量，这些变量是相互关联的，即当我将某些内容写入私有变量时，公共变量也会发生变化。然而，我只想通过使用单独的函数来写私有变量，即将公共变量作为只读变量。我目前的做法是：

#include <iostream>
#include <stdio.h>

class test_vec
{
    private:
        int x, y;
        int data[2];
    public:
        int x_ext, y_ext;
        int data_ext[2];

        test_vec(int x, int y)
        {
            this->x = x;
            this->y = y;
            this->x_ext = this->x;
            this->y_ext = this->y;
        }

        ~test_vec()
        {}

        void set_x(int x)
        {
            this->x = x;
        }

        void set_y(int y)
        {
            this->y = y;
        }
};

int main(void)
{
    std::cout << "Hello World\n";
    test_vec test(1, 2);
    printf("test has the properties (%d, %d)\n", test.x_ext, test.y_ext);//So far, so good
    test.set_x(4);
    test.set_y(10);
    printf("test has the properties (%d, %d)\n", test.x_ext, test.y_ext);//Not updated!
    return 0;
}

如何更改变量之间的链接？目前我已经将两个指针相互复制，但是如何将外部变量“锁定”到内部变量上呢？

Answer 1

不确定它是否是一个好的设计模式，因为内联getter很快但你可以创建对私有变量的常量引用：

class test_vec
{
    private:
        int x, y;
        int data[2];
    public:
        const int &x_ext, &y_ext;
        int data_ext[2];

        // you have to initialize the references before constructor body
        // references cannot be let uninitialized
        test_vec(int x, int y) : x_ext(this->x), y_ext(this->y)
        {
            this->x = x;
            this->y = y;

        }

        ~test_vec()
        {}

        inline void set_x(int x)
        {
            this->x = x;
        }

        inline void set_y(int y)
        {
            this->y = y;
        }
};

当x或y更改x_ext和y_ext时：

Hello World
test has the properties (1, 2)
test has the properties (4, 10)

奖励：不能修改常量引用。这是你在这里读取属性最接近的东西：）

如果您不想要这个限制，只需删除const限定符，但由于您现在鼓励封装，因为您拥有C ++我会按原样放弃它并让编写者在那里遇到问题（更不用说一个好的sed /正则表达式替换可以自动重构所有的写入

Answer 2

您可以将引用用于这些目的。

说你有这个设置：

df[~df.A.apply(pd.Series).duplicated()]

你可以这样：

class myclass{

    public:

                myclass(int pa, float pb);

    int         get_a() const {return a;}
    float           get_b() const {return b;}

    void            set_a(int v) {a=v;}
    void            set_b(float v) {b=v;}

    private:
    //These are the real values, private
    int         a;
    float           b;

    public:
    //These are the references, public
    int&            ref_to_a;
    float&          ref_to_b;        
}

myclass::myclass(int pa, float pb)
    :a(pa), b(pb), ref_to_a(a), ref_to_b(b)
{

}

注意访问设置：引用是公共的，这意味着您可以写入和读取它们。如果你想让他们只读，你可以玩constness。

Answer 3

我不会打扰。只是暂时让成员公开，当你修复了所有外部引用时，将它们设为私有。

class test_vec
{
    public:   // For now.  Will become private later
        int x, y;
    public:   // For now.
        int data[2];
    public:   // For ever
        test_vec(int x, int y)
          : x(x), y(y)   // Prefer initialization to assignment.
        {
        }

        ~test_vec()
        {}

        void set_x(int x)
        {
            this->x = x;
        }
        void set_y(int y)
        {
            this->y = y;
        }

        int get_x() const { return x; }  // etc
};

如果你真的想，你可以让x_ext成为const的引用 - 但它在C ++中更具惯用性，使得getter成为函数。

class test_vec
{
    private:
        int x, y;
        int data[2];
    public:
        int const& x_ext;
        int const& y_ext;

        test_vec(int x_, int y_)
          : x(x_), y(y_)
          , x_ext(x), y_ext(y)  // You *have* to use initialization here.
        {
        }

        ~test_vec()
        {}

        void set_x(int x)
        {
            this->x = x;
        }
        void set_y(int y)
        {
            this->y = y;
        }
};

链接公共和私有变量（具有对私有变量的写访问权限）

3 个答案: