컴파일 타임에 일정한 크기의 배열 ..하지만 파생 클래스에서 만

Question

나는 그 클래스 A 및 B 더 ..이

class A : public O 
{ 
    static const int _nbItems = 3; 
    ... 
}; 

class B : public O 
{ 
    static const int _nbItems_mine_mine = 7800; 
    ... 
}; 

... 

그들은 추상적 부모 클래스 O 모든 inheritate하는 는 .. Item의 수집을 관리하고 그들이 원하는대로 아이들이 놀러 못하게하는 방법 알고

class O 
{ 
private: 

    // The kids won't be able to access this structure directly for it is carefully updated 
    Item _items[size];   

    // (I mean.. *truly*, look :) 
    void update() // called by the clock 
    { 
     for(int i(0); i < size; ++i) /* things involving */ _items[i] /*, its environment etc.*/ 
    }; 

protected: 

    // They may set their items this way only: 
    void setItemNo(int id, BuildInformation const& buildInfo) 
    { 
     /* 
     * check whether or not the item has already been added.. 
     * perform everything that must be done to welcome a new item.. 
     * well.. 'so many things the kids do not need to be aware of. 
     */ 

     // and then: 
     _items[id] = Item(buildInfo); 

    }; 

    // .. retrieve information about the current state of their items this way only: 
    SomeInformation getItemState(int id) const {return _items[id].currentState();}; 

    // .. and eventually change some of their properties this way only: 
    void setItemProperty(int id, Property const& newProperty) 
    { 
    /* checks, updates, eventual repercussions on other items and the environment */ 
    _items[id].setProperty(newProperty); 
    }; 
}; 

O::_items에 대한 구조로 사용하여 스택에 할당 된 Item이 모두에 할당 된 구조로 사용할 수 있습니까? 크기가 궁극적으로 컴파일 시간에 알려지기 때문에 가능한 것이어야합니다.

그것을 anoter 방법을 넣어 : 어떻게 자신의 길을 찾을 *nbItems* 정보가 아직 정의되지 않은 O에, 컴파일러 그들은 여전히 ​​문자 상수 알고하자 패션에 O::size까지 할 수 있을까?

---

추신 : O가 기록되는 시간, 나는 분명히 언젠가는있을 수있는 모든 가능한 파생 클래스를 인식하지입니다. 중간 파생 클래스 다음

class O 
{ 
    virtual size_t size() const = 0; 
    virtual Item * data() const = 0; 

    void update() 
    { 
     for (Item * p = data(), * e = p + size(); p != e; ++p) 
     { 
      // use *p 
     } 
    } 

public: 
    virtual ~O() {} 
}; 

: 다음

template <size_t N> class OWithArray : public O 
{ 
public: 
    static size_t const nItems = N; 
private: 
    Item items[N]; 
    virtual size_t size() const { return nItems; } 
    virtual Item * data() const { return items; } 
}; 

그리고는 모두 실제 파생 클래스가 중간 클래스에서 파생 :

Answer 1

당신은 배열하지 않고 기본 클래스 O을 가질 수

을

class A : public OWithArray<3> 
{ 
    // ... 
}; 

Answer 2

class O { 
    private: 
    Item* items; 
    unsigned int number_of_items 

    protected: 
    O (Item* itemsstorage, unsigned int n_items) 
    : items (itemsstorage), number_of_items (n_items) { ... } 

    // you'll probably need something like the following 
    // make it private rather than using "= delete" prior to C++11 
    O & operator = (const O &) = delete; 
    O (const O &) = delete; 
    O (O &&) = delete; 

    public: 
    virtual ~O() { } 
} 

class A : public O { 
    private: 
    enum { howManyItems = 3 }; 
    Item allMyItems [howManyItems]; 

    public: 
    A() : O (allMyItems, howManyItems) { } 
} 

또는을 템플리트 A가 더 유연하게 : 당신이 다형의 ('의 O으로 S'의 A을 치료하는 경우을

template<unsigned int N> 
class A : public O { 
    private: 
    Item allMyItems [N]; 

    public: 
    A() : O (allMyItems, N) { } 
} 

참고 클래스 O에서 가상 소멸자를 필요로하는 것은 의미 : 당신은 확실히,하지 않는 한 당신은 절대적으로 100 % 확신하지 못합니다!) !!!!