Question

这是一个想法：我有一个有一些成员变量的类，比如x。此类还有一个方法A()，它不会修改成员变量，但会返回有关它们的信息。还有一种方法B() 修改成员变量。基本上，这就是设置：

class Class
{
    int x;
    Class(int x) : x(x) { }

    int A() { return x; /* info about x */ }
    void B() { x++; /* updates x! */ }
}

到目前为止一切顺利。但是现在我想要在整个项目中使用这个类的一些特殊版本，我希望它有一组特定的成员变量，比如x = 3.我的想法是添加一个{{ 1}}成员到const static Class mySpecialCase，并在必要时引用Class。

问题是，我需要在此对象上调用Class::mySpecialCase来获取一些信息，但不希望在此对象上调用A()，因为它会修改{{1}这将影响“特殊情况”的所有未来使用。

关于如何解决这个问题的任何想法？

Answer 1

调用Class::mySpecialCase.B()已经非法，因为mySpecialCase为const且B()不是const成员。您只需要通过A() A()成员函数来调用const即可：

class Class
{
    int x;
public:
    Class(int x) : x(x) { }

    static const Class mySpecialCase;

    int A() const { return x; /* info about x */ }
    void B() { x++; /* updates x! */ }
};

// In class.cpp:
const Class Class::mySpecialCase{3};

Answer 2

问题是，我需要在这个对象上调用A（）来获取一些信息，但是不希望在这个对象上调用B（），因为它会修改x，

声明对象，将B()声明为const，但不声明A()：

 class Class {
     public:
          [...]
          int A();
          void B() const;
 };

 // Initialize const object.
 const Class specialCase(3);

调用specialCase.A()将是编译错误，但specialCase.B()仍然可以，因为const修饰符向编译器指示此方法不会更改对象。

Answer 3

到目前为止一切顺利。

不是真的。 A应为const：

int A() const { return x; /* info about x */ }

但是现在我想要这个类的一些特殊版本

version ，你的意思是实例，对吗？

添加一个静态成员函数，返回对Class的静态本地实例的引用：

#include <iostream>

class Class
{
public:
    int x;
    Class(int x) : x(x) { }

    int A() const { return x; /* info about x */ }
    void B() { x++; /* updates x! */ }

    static Class &SpecialInstance()
    {
        static Class instance(3);
        return instance;
    }
};

int main()
{
    Class a(1);
    Class b(2);
    Class c = Class::SpecialInstance();

    std::cout << c.A() << "\n";
}

在静态const成员上调用特定方法

3 个答案: