小编Bob*_*Bob的帖子

我正在尝试一些东西,我不知道代码是怎么回事.我有一个类,它有一个静态成员和默认构造函数和一个重载的.

class Remote
{
public:
    static std::vector<Remote*> channels;

    static void interrupt() {
        for (Remote* r : channels) {
            r->ProcessInterrupt();
        };
    }

    void ProcessInterrupt() {
        std::cout << "ProcessInterrupt called.";
    };

    Remote(const int a) {
        std::cout << "Remote(const int a) called.\n";
        channels.push_back(this);
    }
    Remote() {
        Remote(1);
        std::cout << "Remote() called.\n";
    }
    ~Remote() {
        std::vector<Remote *>::iterator ch = std::find(channels.begin(), channels.end(), this);
        if (ch != channels.end()) {
            channels.erase(ch);
        };
    }
};

在main.cpp中,我声明了Remote类的两个实例.我现在注意到的是,如果我使用默认构造函数实例化它们,则指针不会添加到向量中.然后我尝试使用重载的构造函数,它确实将它添加到向量.

Remote r1 = Remote();
Remote r2 = Remote(1);
std::cout << Remote::channels.size() << …

我创建了一个有静态成员的类.每次创建对象时,我都希望在静态成员中添加指向此对象的指针.

头文件:

#include <vector>

class A
{
public: 
    A(const int pin);
    ~A();
    static std::vector<A*> channels;

private:
    int pin_number;
}

cpp文件:

 #include "A.h"

 std::vector<A*> A::channels;

 A::A(const int pin) : pin_number(pin) { A::channels.push_back(this); };
 A::~A() { 
     std::vector<A*>::iterator ch = std::find(A::channels.begin(), A::channels.end(), this);
     if (ch != A::channels.end()) {
        A::channels.erase(ch);

 }

在main.cpp中我想声明对象.但是,当我声明并初始化为全局变量时,它似乎不起作用:

A a1{ 1 };
A a2{ 2 };

int main() {
    std::cout << "Vector size: " << A::channels.size() << std::endl;
}

上面提到的代码似乎不起作用.在对象的构造函数中,我看到向量被填充.在上述情况下输出为0.

但是,对于下面的2个代码示例,似乎确实有效.

样本1:

A *a1;
A *a2;

int main() {
    a1 …

我正在编写一些代码来理解一些设计模式。我正在研究 C# 和 C++，以更好地理解这两种语言。以下代码给出了 Duck::fly() 和 Duck::quack() 不可访问的错误。有人能帮我解决这个错误吗？

#include "stdafx.h"
#include "iostream"
#include "string"

using namespace std;

int main()
{
    std::cout << "Object Oriented Pattern:\n\n";

    MallardDuck Duck1;
    Duck1.fly();
    Duck1.quack();

    RubberDuck Duck2;
    Duck2.fly();
    Duck2.quack();

    std::cin.get();
    return 0;
};

class IFlyBehavior
{
public:
    virtual void fly();
};

class IQuackBehavior
{
public:
    virtual void quack();
};

class Duck
{
protected:
    IFlyBehavior FlyBehavior;
    IQuackBehavior QuackBehavior;

public:
    void fly()
    {
        FlyBehavior.fly();
    }
    void quack()
    {
        QuackBehavior.quack();
    }
};

class RubberDuck : Duck
{
public:
    RubberDuck() …