C++ 对静态常量成员调用特定方法

我的想法是：我有一个类，它有一些成员变量，比如

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。我的想法是在

Class

中添加一个

const static Class mySpecialCase

成员，必要时只需参考

Class:：mySpecialCase

然而，问题是，我需要在此对象上调用

A（）

，以获取一些信息，但不希望在此对象上调用

B（）

，因为它会修改

x

，这将影响“特殊情况”的所有未来用法

---

关于如何解决这个问题有什么想法吗？

调用

Class:：mySpecialCase.B（）

已经是非法的，因为

mySpecialCase

是

const

，而

B（）

不是

const

成员。您只需通过创建

A（）

A

const

成员函数，就可以调用

A（）

：

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};

---

调用

Class:：mySpecialCase.B（）

已经是非法的，因为

mySpecialCase

是

const

并且

B（）

不是

const

成员。您只需通过创建

A（）

A

const

成员函数，就可以调用

A（）

：

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};

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

将对象和

B（）

声明为

const

，而不是

A（）

：

调用

specialCase.A（）

将是一个编译错误，但是

specialCase.B（）

仍然可以，因为

const

修饰符向编译器指示此方法不会更改对象

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

将对象和

B（）

声明为

const

，而不是

A（）

：

调用

specialCase.A（）

将是一个编译错误，但是

specialCase.B（）

仍然可以，因为

const

修饰符向编译器指示此方法不会更改对象

到目前为止还不错

不是真的<代码>A应为

常量

：

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

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

所谓版本，你指的是实例，对吗

添加一个静态成员函数，该函数返回对

类的静态本地实例的引用：

#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";
}

#包括
班级
{
公众：
int x；
类（intx）：x（x）{}
int A（）常量{return x；/*关于x的信息*/}
void B（）{x++；/*更新x！*/}
静态类和SpecialInstance（）
{
静态类实例（3）；
返回实例；
}
};
int main（）
{
a类（1）；
b类（2）；
c类=类：：SpecialInstance（）；
标准：：cout
到目前为止还不错

不完全是。
A
应该是
const
：

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

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

所谓版本，你指的是实例，对吗

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

#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";
}

#包括
班级
{
公众：
int x；
类（intx）：x（x）{}
int A（）常量{return x；/*关于x的信息*/}
void B（）{x++；/*更新x！*/}
静态类和SpecialInstance（）
{
静态类实例（3）；
返回实例；
}
};
int main（）
{
a类（1）；
b类（2）；
c类=类：：SpecialInstance（）；
std:：cout关于
static int A（）{return mySpecialCase.x；}
？@leems问题是我必须将其推广到多个成员变量和多个特殊情况。我想我误解了。我以为你想写
Class:：A（）
，然后应该“向前”写对于静态成员。我不理解关于“特殊情况”的这个想法。你肯定只是在问一个具有特定值的只读实例吗？关于
static int a（）{return mySpecialCase.x；}
？@leemes问题是我必须将其推广到多个成员变量和多个特殊情况。我想我误解了。我以为你想编写
类：：A（）
，然后将其“转发”到静态成员。我不理解“特殊情况”的概念.您肯定只是询问具有特定值的只读实例？