1

したがって、「大きな」クラスがあり、少なくとも100個のオブジェクトのベクトルを保持するA別のクラスがあります。多くの情報を再利用できるため、すべてのオブジェクトをとしてクラスに格納することはお勧めできません。BABvector<A>

クラスBに、同様のプロパティをすべて保持しA、それに作成するテンプレートを用意することを考えてvector<A*>いました。しかし、それはそれらをすべて同じにします...

いくつかの違いだけを複数回保存する必要があるように、クラスの同様の変数を保存する方法はありますか?

最小限の作業例

#include <iostream>

// suppose an int is big:
struct A { // create struct which holds 3 ints
    A() : a(0),b(0),c(0) {} //ctor

    void print() { // print all variables
        cout << a << ", " << b << ", " << c << endl;
    }
    int a,b,c;
};

class B { // create object that holds a vector of A
public:
    B(int vectorSize) {
        vector_A.resize(vectorSize);
        vector_ptr_A.resize(vectorSize);
    }

    void initValues() {
        ///////////////////////////////////////
        // METHOD 1
        vector_A.resize(vectorSize); // resize 
        for (int i=0; i<vector_A.size(); ++i) {
            vector_A[i].a = rand() % 100; // randomize A::a
            vector_A[i].b = 5;            // only B wants A::b to be 5
            vector_A[i].c = 10;           // only B wants A::c to be 10
        }
        ///////////////////////////////////////

        ///////////////////////////////////////
        // METHOD 2
        A_template.b = 5;  // only B wants A::b to be 5
        A_template.c = 10; // only B wants A::c to be 10
        vector_ptr_A.resize(vectorSize,&A_template); // point to template
        for (int i=0; i<vector_ptr_A.size(); ++i) {
            vector_A[i].a = rand() % 100; // randomize A::a
        }
        ///////////////////////////////////////
    }

    void print1() { // prints vector_A[i]
        for (int i = 0; i < vector_A.size(); ++i) {
            vector_A[i].print();
        }
    }
        void print2() { // prints vector_ptr_A[i]
        for (int i=0; i < vector_ptr_A.size(); ++i) {
            vector_ptr_A[i]->print();
        }
    }

    // method 1
    vector<A> vector_A; // a big, big vector

    // method 2
    A A_template;
    vector<A*> vector_ptr_A; // all the same
};

int main() {
    srand( time(NULL) );
    B b(10);
    b.initValues();

    cout << "METHOD 1\n";
    b.print1();             // as desired, but inefficient
    cout << "\nMETHOD 2\n";
    b.print2();             // all the same output
}

編集

最小限の作業例が少し混乱しているため、いくつかの明確化。また、より明確にするために今それを適応させました。

クラスのメンバーは、ユーザーAによって設定されることを意図してBいます。ユーザーは、たとえばA::a、ベクトルの各要素 (乱数で表される) を定義し、他の 2 つ (A::bおよびA::c) は で定義されBます。クラスAは だけが使用するクラスではなくB、ユーザーまたは他のクラスによっても使用されます。

したがって、基本的にはメソッドを求めているので、ベクターのすべての要素に対してA::bandを設定する必要はありませんがA::c、1 回だけです。A::a設定する要素ごとに異なります。

これが必要な理由を説明するには、クラスAは私のプログラム内のSpriteクラスでBあり、スプライトをタイルとして印刷できる必要があり、という名前が付けられてTileMapいます。このように、ベクトルはウィンドウに描画できるTileMap多くの を保持しSpriteますが、多くの情報はそれらすべてのタイル (テクスチャ タイル サイズ、描画タイル サイズ、テクスチャ ファイルなど) でまったく同じであり、私はそうではありません。すべてのタイルにこれらすべての変数を設定したいと考えています。Spriteベクター内のすべてに使用できるある種のテンプレートを作成したいと思います。この方法は、より簡単で省スペースであるだけでなく、より安全でもあります。これらの値はすべてまったく同じになることがわかっています。

4

3 に答える 3

1

いくつかの説明が必要ですが、あなたの質問を理解した上で行きます。 

struct Common_A_Members
{
  int x;
  double y;
};

struct Uncommon_A_Members
{
  unsigned int this_member_changes;
};

struct A : public Common_A_Members, public Uncommon_A_Members
{
  A(const Common_A_Members& c, const Uncommon_A_Members& d)
  : Common_A_Members(c), Uncommon_A_Members(d)
  { ; }
};


struct B
{
  Common_A_Members a_common;
  std::vector<Uncommon_A_Members> a_uncommon;
};

上記の例では、概念クラスは 2 つの部分に分割されます。一方の部分には、変更されない値 (Common_A_Members) と変更される値 (Uncommon_A_Members) が含まれます。これにより、定数Bデータの 1 つのメンバーとデータのベクトルを持つことができます。概念クラスには、定数データと変化するデータを結合するコンストラクターがあります。 changingA

の 2 つのメンバーはBセットです。異なる定数値を持つ概念クラスについては、セットをコピーまたは繰り返す必要があります。

理論は、変化するデータから一定のデータを除外することです。

于 2013-03-17T18:07:09.513 に答える
1

変数 b、c が A のすべてのインスタンスで常に同一である場合、それらを A で静的にします。

B の 1 つのインスタンスに格納されている A のインスタンスのセットに対して変数 b,c が同一である場合は、代わりに B に b,c を配置することを検討してください。

変数 b,c が A の一部のセットに対してのみ同一である場合、b,c を独自の「構成」クラス C に分解し、C へのスマート ポインターを A に格納することを検討します。これは、b,c が十分に大きい、または共有されていることを前提としています。追加の管理が価値があるように、十分なインスタンスによって。

ところで、print2() 関数は vector_ptr_A[i] ではなく vector_ptr_A[0] を使用する必要がありますか? （できればコメントでこれを尋ねたでしょう...）

編集：3番目のオプションの参照バージョン：

class A_Config // stores common parts of A
{
public:
  A_Config(int a, int b) : m_a(a), m_b(b) {}
private:
  int m_a;
  int m_b;
};

class A // store parts changing for each instance and a reference to the common parts
{
public:
  A(int changing, A_Config& shared) : m_changing(changing), m_shared(shared) {}
private:
  int m_changing;
  A_Config& m_shared;
};

class B
{
public:
  B(int a, int b) : conf(a,b) {} // the common parts of A initialized 
                                 // only once when B is created

  void add_A(int changing) // add the changing parts when A is added
  {
    v.push_back( A(changing, conf) );
  }

private:
  A_Config conf;
  vector<A> v;
};
于 2013-03-17T18:24:06.873 に答える
0

別の方法：

std::vector <std::reference_wrapper<A>> vector_ref_A;

例：

A a, b, c;

std::vector < std::reference_wrapper < A >> vector_ref_A = {a, b, c};

for (int i = 0; i < vector_ref_A.size(); ++i) {
    vector_ref_A[i].get().randomize();
}

for (int i = 0; i < vector_ref_A.size(); ++i) {
    vector_ref_A[i].get().print();
}
于 2013-03-17T17:37:20.970 に答える