1

別のクラスの単一のインスタンスを共有する必要がある複数のクラスがあります。公的には、このクラスが存在することは不明です。次のようなことをするのは適切ですか？（書かれたとおりにテストされました）

#include <iostream>

class hideme
{
    private:
        int a;

    public:
        void set(int b) { a = b; }
        void add(int b) { a += b; }
        int get() { return a; }

        hideme() : a(0) { }
};


class HiddenWrapper
{
    protected:
        static hideme A;

};

hideme HiddenWrapper::A;

class addOne : public HiddenWrapper
{
    public:
        void add() { A.add(1); }
        int get() { return A.get(); }
};

class addTwo : public HiddenWrapper
{
    public:
        void add() { A.add(2); }
        int get() { return A.get(); }
};


int main()
{
    addOne a;
    addTwo b;

    std::cout << "Initialized: " << a.get() << std::endl;

    a.add();
    std::cout << "Added one: " << a.get() << std::endl;

    b.add();
    std::cout << "Added two: " << b.get() << std::endl;

    return 0;
}

価値があるのhidemeは、私がファサードを設計しようとしているライブラリの一部であり、他のクラスには、静的と相互作用するライブラリのメンバーがありますhideme。

さらに、作成されたヘッダーファイルにHiddenWrapper対応するソースファイルがない場合、静的メンバーを定義するのに最適な場所ですか？インクルードガード付き。

この問題を解決する他の方法はありますか？私が想像できる限り（それほど遠くはありませんが）、それ以外の場合は友情でしか解決できませんでしたが、私は警戒しています。

4

4 に答える 4

0

これは、他のクラスの周りにシングルトンを実装し、それをユーザーから隠します。

class hideme {};

// fwd declarations
class x;

// library internal
class S
{
  S() = delete;
  S(S const&) = delete;
  void operator=(S const&) = delete;
private:
  static hideme& getInstance()
  {
    static hideme instance;
    return instance;
  }

  friend x;
};

// library classes
class x {
  hideme& s;
public:
  x() : s(S::getInstance()) {}
};

int main()
{
  x x;
  return 0;
}

hideme これは、他のオブジェクトがインスタンスを使用しなくなったときにインスタンスを実際に破棄したい場合には対応しません。そのためには、参照カウントを使用してもう少し独創的にする必要があります。

また、これは悪い考えだと思います。シングルトンはほとんどの場合そうです。

于 2012-11-08T23:01:28.740 に答える
0

コンストラクター（継承ではなく構成とも呼ばれます）を介して（参照またはポインターによって）共有リソースを注入する方がよい場合があります。この方法により、共有するかどうかを指定できます（たとえば、コードのスレッドセーフなバリアントを共有するかどうかを指定できます）。詳細については、 http：//de.wikipedia.org/wiki/Inversion_of_Controlの原則を参照してください。

于 2012-11-08T22:57:08.457 に答える
0

クラスを使用する変換ユニットの外部でクラスにアクセスできないようにすることで、クラスへのアクセスを防ぐことができます。

// public_header.h

class A {
    void bar();
};
class B {
    void foo();
}

// private_implementation.cpp
#include "public_header.h"

namespace {
  class hidden { void baz() {} };

  hidden h;
}

void A::bar() {
    h.baz();
}
void B::foo() {
    h.baz();
}

このクラスは、A::barとB::fooでのみ使用できます。タイプhiddenと変数hは技術的にはまだ外部リンケージを持っていますが、他の翻訳ユニットはそれらの名前を言うことができません。

于 2012-11-08T23:31:54.820 に答える
0

一般に、主要部分に変数があり、それをすべてのクラスと共有したい場合の最良のアプローチ。
たとえば、クラスXがこの変数に変更を加えた場合、その変更はメインの変数にも発生します。EXTEND
*********************を使用できます。 ***メイン*********************

#include <iostream>
using namespace std;

#include "Game.hpp"
//0: not specified yet; 1:singlemode; 2:multiplayerMode
int playingMode = 0;

int main()
{
    Game game;
    game.Run();
    std::cout<< playingMode << std::endl; 
    return 0;
}

***********************クラスX*****************

#include <iostream>
using namespace std;

extern int playingMode;

....
....

if(m_isSinglePressed)
    {
        playingMode = 1;
        ...

    }
    else if(m_isMultiPressed)
    {
        playingMode = 2;
        ...
    }
于 2020-12-05T18:18:22.480 に答える