Dotaz: Statická inicializace pole struktur v C++

[pou]

Dobrý den,

Dejme tomu že mám tuto třídu v C++

class TEST{

public:
  TEST();
   typedef struct {
        int a;
   }ITEM;

const ITEM items[];

};

Nyní bych chtěl v konstruktoru třídy TEST() naplnit pole items. Plánuji potom zdědit tuto třídu (TEST) a každý potomek si vytvoří svoje pole items.

Jak na to? Použití std::vector nebo array atd není možné (embeddded).

Jediná pro mě zatím funkční varianta je mít takovýto konstruktor:

TEST(){
    ITEM asfafafsfff[]={
        {4},{5}
    };
    itms=asfafafsfff;
}

Ale vůbec se mi to nelíbí. Navíc items nemůže být const a busí být definován jako ITEM * items.

Odpovědi

[X]

Domaci ukol?

[pou]

Ne, ale díky za odpověď

[Andrej]

To je jakýsi podivný mix C++ (class), C (typedef struct) a kdoví, možná i Javy (items[]), ale nejspíš to má být „nekonečné“ pole na konci C99 struktury, které ovšem není ani vzdáleně kompatibilní s C++ (bez přetěžování new a delete), protože samo od sebe není jasné, jak tam mají fungovat konstruktory a destruktory…

Použití std::vector nebo array atd není možné (embeddded).

V jakém slova smyslu to není možné? To ten embedded systém nemá alokátor paměti? std::array bude fungovat bez dynamické alokace, přesně k takovému použití je určené…

Kdo / co určuje velikost pole items? Je k tomu přetížený operátor new a delete? Jak vypadá?

Ten každý potomek má být ve skutečnosti každá podtřída nebo každá instance? Nebylo by v prvním případě lepší mít to pole statické? (Ať tak nebo tak, asi by mělo být protected a/nebo const.)

#include <array>
#include <cstdint>
#include <utility>

namespace {

template <std::size_t Size>
struct Test1 {
  struct Item {
    int a;
  };

  template <typename... ALike>
  Test1(ALike&&... as) : items_{{.a = std::forward<ALike>(as)}...} {
    static_assert(sizeof...(as) <= Size);
  }

 protected:
  const Item items_[Size];
};

template <std::size_t Size>
struct Test2 {
  struct Item {
    int a;
  };

  template <typename... ALike>
  Test2(ALike&&... as) : items_{Item{.a = std::forward<ALike>(as)}...} {
    static_assert(sizeof...(as) <= Size);
  }

 protected:
  const std::array<Item, Size> items_;
};

}  // namespace

int main() {
  Test1<6> t{1, 2, 3, 4, 5};
  Test2<5>{1, 2, 3, 4};
}

[pou]

Dobrý den, díky za odpověď.

Máte pravdu std::array použít můžu - kompilátor to zkompiluje.

Asi jsem to použil nešťastně (mix C/C++) - proto se rád nechám poučit.

Nejlépe asi napsat čeho chci dosáhnout:

Snažím se vytvořit třídu, která na displej vykresluje menu. Položky v menu budou právě v tom seznamu - tedy každá podtřída bude mít svůj set položek. Instance dané podtřídy již seznam měnit nebude (může tedy být konstantní).

No a celá moje snaha je, aby to bylo přehledně napsané (tedy v konstruktoru jednodušše naplním toto pole) a nejlépe konstantní tak aby se vše uložilo do paměti programu a ne do RAM paměti (položky totiž budou obsahovat text ale i obrázky-ikony).

Díky

[luky]

To nejde, protoze vnorene pole ve strukturalnim typu musi mit v C++ znamou velikost v dobe prekladu. Musite zadat velikost nebo pouzit ukazatel a pole mit jinde.