通过传递对类变量的引用来初始化该类变量 我有一个有趣有趣的C++练习：

这主要是：

int main(void)
{
    Exam e = Exam(&Exam::cheat);
    e.kobayashiMaru = &Exam::start;
    (e.*e.kobayashiMaru)(3);
    Exam::cheat = true;
    if (e.isCheating())
        (e.*e.kobayashiMaru)(4);
    return (0);
} 

这是请求的输出：

[The exam is starting]
3 Klingon vessels appeared out of nowhere.
You lost again.
[The exam is starting]
4 Klingon vessels appeared out of nowhere.
Win !

现在需要创建

Exam

类以获得正确的输出。 以下是我所做的：

class Exam
{
public:

    Exam(bool *_cheat);

    typedef void (Exam::*func)(int);
    void            start(int);
    bool                       isCheating();
    static bool               cheat;
    func                       kobayashiMaru;
};

我遇到了

考试（&test:：cheat）

的问题。到目前为止，我所了解的是，

考试

是取它自己的

作弊

变量的地址。进入

考试时

的构造函数

作弊

未初始化。所以对我来说，我会在这里用

false

初始化它

Exam::Exam(bool * _cheat)
{
   *_cheat = false;
}

但是通过这样做，我得到了

Exam（&Exam:：cheat）

的多重定义。我不确定我的想法，也许有人能告诉我这里到底发生了什么吗？

改变：

static bool cheat;

致：

在

考试

类中，允许每个新对象使用自己的值处理自己的

作弊

变量

当您使用构造函数创建新对象时，构造函数将按给定值初始化您的

check

变量，如下所示：

Exam::Exam(bool isCheating)
{
   this->cheat = isCheating;
}

Exam::Exam()
{
   cheat = false;
   //or cheat = true;
}

exam1->methodName(1243);
exam2->secondMethodName(true);
exam2->thirdMethodName();
exam3->addFriend(&exam1);

class Exam
{
public:
    Exam(bool cheat) : m_cheat(cheat) {}

    // don't expose member variables directly - use accessor functions
    void setCheating(bool cheat) { m_cheat = cheat; }
    bool isCheating() const { return m_cheat; }

    void start(int);
private:
    bool               m_cheat;
};

或者，如果您想在默认情况下将

cheat

变量初始化为false/true，则可以将构造函数设置为如下所示：

Exam::Exam(bool isCheating)
{
   this->cheat = isCheating;
}

Exam::Exam()
{
   cheat = false;
   //or cheat = true;
}

exam1->methodName(1243);
exam2->secondMethodName(true);
exam2->thirdMethodName();
exam3->addFriend(&exam1);

class Exam
{
public:
    Exam(bool cheat) : m_cheat(cheat) {}

    // don't expose member variables directly - use accessor functions
    void setCheating(bool cheat) { m_cheat = cheat; }
    bool isCheating() const { return m_cheat; }

    void start(int);
private:
    bool               m_cheat;
};

您也可以处理多个构造函数

现在要从

Exam

类创建新对象，请使用：

Exam *exam1 = new Exam(true); //Will initialize cheat as false
Exam *exam2 = new Exam(false); //Will initialize cheat variable as true

然后访问exam1和exam2对象中的方法，如下所示：

Exam::Exam(bool isCheating)
{
   this->cheat = isCheating;
}

Exam::Exam()
{
   cheat = false;
   //or cheat = true;
}

exam1->methodName(1243);
exam2->secondMethodName(true);
exam2->thirdMethodName();
exam3->addFriend(&exam1);

class Exam
{
public:
    Exam(bool cheat) : m_cheat(cheat) {}

    // don't expose member variables directly - use accessor functions
    void setCheating(bool cheat) { m_cheat = cheat; }
    bool isCheating() const { return m_cheat; }

    void start(int);
private:
    bool               m_cheat;
};

这些只是例子

希望我能理解你的问题。：）

您有一些问题（在下面的评论中描述）

我在考试（考试：：作弊）方面遇到了问题。我 到目前为止了解到的是，考试取的是自己作弊的地址 变量当进入考试的构造函数时，作弊是未初始化的。 所以对我来说，我会在这里用false初始化它

静态变量在创建类的第一个实例之前初始化。您有两个问题：1）您没有初始化静态成员变量，2）您没有将其视为静态成员变量

将变量声明为

static

意味着它将在类的所有实例之间共享（例如，

cheat

将有一个内存位置）。除非你想让每个参加

考试的人在一个人作弊时就作弊，否则这不太可能是你想要的

要解决此问题，您希望您的
考试
类看起来更像这样：

Exam::Exam(bool isCheating)
{
   this->cheat = isCheating;
}

Exam::Exam()
{
   cheat = false;
   //or cheat = true;
}

exam1->methodName(1243);
exam2->secondMethodName(true);
exam2->thirdMethodName();
exam3->addFriend(&exam1);

class Exam
{
public:
    Exam(bool cheat) : m_cheat(cheat) {}

    // don't expose member variables directly - use accessor functions
    void setCheating(bool cheat) { m_cheat = cheat; }
    bool isCheating() const { return m_cheat; }

    void start(int);
private:
    bool               m_cheat;
};

对
主功能的相应更改

int main(void)
{
    Exam e(false);
    e.start(3);
    e.setCheating(true);
    if (e.isCheating())
        e.start(4);
    return 0;
}

谢谢你的回答。但事实上，我们的目标是用强制的方法进行练习main@Robin我不明白两件事。1.为什么要创建这样的新对象：Exam e=Exam（&Exam:：cheat）；代替考试*e=新考试（考试：：作弊）；2.方法start（）；在类内部是非静态的，在这里调用它就像调用静态函数一样：Exam:：start（）；对我来说，这真的很奇怪。是的，我当然可以实现这个输出，但有另一个主“结构”。因为它是一个强制的主。我没有做到，也不能改变。练习的所有困难都在这里：用给定的main生成所要求的输出。更改main在这里没有兴趣，我知道如何创建一个类并使用它…谁创建了那个奇怪的main？：我不能改变主。。。你必须用给定的主。。。我想我最好删除我的帖子