Statische 2D Char Arrays mit verschiedenen Größen

[Werner D. (werner_d350)]

Hi, kann man statische 2D Char Arrays mit verschiedenen Größen 
definieren ?
Normalerweise sind die Größen immer gleich, also z.B. char a[5][10].
Also 5 Char Arrays mit jeweils 10 Chars.

Kann ich jetzt die ersten 2 Char Arrays mit 100 Bytes deklarieren ?
So daß
sizeof(a[0]) = 100
sizeof(a[1]) = 100
sizeof(a[2]) = 10
sizeof(a[3]) = 10
sizeof(a[4]) = 10

Ich möchte keine dyn. Arrays auf dem Heap haben.

Viele Grüße
Werner

[Michael B. (laberkopp)]

Werner D. schrieb:
> Kann ich jetzt die ersten 2 Char Arrays mit 100 Bytes deklarieren ?

char a1[100],a2[100],a3[10],a4[10],a5[10];
char (*a)[5]={a1,a2,a3,a4,a5};

Zugriff mit

a[x][y]

und nicht

a[x,y]

[Werner D. (werner_d350)]

Michael B. schrieb:
> char a1[100],a2[100],a3[10],a4[10],a5[10];
> char (*a)[5]={a1,a2,a3,a4,a5};

Funktioniert das auch unter c++ ?
Ich bekomme da ein Compiler Fehler error: scalar object 'a' requires one 
element in initializer

[Mikro 7. (mikro77)]

Michael B. schrieb:
> char (*a)[5]= ...
Das wäre ein pointer auf ein array mit 5 chars.

Es sollte wohl heißen:

char *a[5]={a1,a2,a3,a4,a5};

Der sizeof operator funktioniert damit allerdings nicht so wie du dir 
das wünschst:

Werner D. schrieb:
> Kann ich jetzt die ersten 2 Char Arrays mit 100 Bytes deklarieren ?
> So daß
> sizeof(a[0]) = 100
> sizeof(a[1]) = 100
> sizeof(a[2]) = 10
> sizeof(a[3]) = 10
> sizeof(a[4]) = 10

[Werner D. (werner_d350)]

Mikro 7. schrieb:
> Es sollte wohl heißen:char *a[5]={a1,a2,a3,a4,a5};

Da waren sie wieder, die Probleme mit den Pointern :))

Danke, compilieren hat schon mal funktioniert. Muß ich mir nur überlegen 
was ich anstelle von sizeof mache.

[Harald K. (kirnbichler)]

Werner D. schrieb:
> Muß ich mir nur überlegen
> was ich anstelle von sizeof mache.

Na, was willst Du erreichen?

Willst Du zur Laufzeit herausfinden, wie groß Deine Arrays sind, und das 
nur aus a[] heraus?

Das könntest Du mit einem zusätzlichen Array erreichen:

char a1[100],a2[100],a3[10],a4[10],a5[10];
char *a[5]={a1,a2,a3,a4,a5};
char s[5]={sizeof(a1),sizeof(a2),sizeof(a3),sizeof(a4),sizeof(a5)};

(Übrigens kann bei der Arraydefinition für a[] und s[] die 5 weggelassen 
werden, der Compiler kann selbst zählen und bestimmt die Anzahl der 
Arrayelemente aus der Anzahl der Initialisierer)

[Wilhelm M. (wimalopaan)]

Du fragst nach C++? Dann nimm std::array<>. Weil nun unterschiedlich 
große Arrays jeweils unterschiedliche DT haben, kann man die Arrays oder 
Zeiger darauf nicht in einem anderen weiteren homogenen Container 
speichern. Da kommt std::variant<> ins Spiel. Zwar könnte man auf die 
Zeiger verzichten und die Array-Typen zu den Parametern des 
std::variant<> machen, was aber ungünstig ist, weil dann der 
Speicherbedarf steigt (std::variant<> ist eine type-safe-union). Also 
nimmt man Zeiger.

#include <cstdint>
#include <array>
#include <variant>

using a1_t = std::array<char, 100>;
using a2_t = std::array<char, 10>;
using v_t = std::variant<a1_t*, a2_t*>;

a1_t a1;
a1_t a2;
a2_t a3;
a2_t a4;
a2_t a5;

int main() {
    std::array<v_t, 5> aa{&a1, &a2, &a3, &a4, &a5};

    uint16_t l = 0;

    for(auto& e: aa) {
        std::visit([&](auto&& a){
            l += a->size();
        }, e);
    }
    return l;
}

[Wilhelm M. (wimalopaan)]

Und wenn Du die Große der Arrays nicht als Compile-Zeit-Konstante 
benötigst, kannst Du auch gut ein std::span<> nehmen:

#include <cstdint>
#include <array>
#include <variant>
#include <span>

using a1_t = std::array<char, 100>;
using a2_t = std::array<char, 10>;

a1_t a1;
a1_t a2;
a2_t a3;
a2_t a4;
a2_t a5;

int main() {
    uint16_t l{};

    std::array<std::span<char>, 5> bb{a1, a2, a3, a4, a5};
    for(const auto& s: bb) {
        l += s.size();
    }

    return l;
}

[Daniel A. (daniel-a)]

In C ist dies nicht möglich. Aber normalerweise braucht man sowas auch 
nicht. Dann packt man hat 2 Arrays in ein Struct.

struct {
  char a[5][10];
  char b[2][100];
} x;

Oder man macht sich eine Funktion (ungetestet):

#define SIZES X(5,10) X(2,100)
#define X(a,b) a*b+
typedef char specialarray_t[SIZES 0]
#undef X
size_t get_entry(char** ret, specialarray_t array, size_t index){
#define X(a,b) \
  if(index < a){ \
    *ret = array + index * b; \
    return b; \
  } \
  array += a*b; \
  index -= a;
  SIZES
#undef X
  *ret = 0;
  return 0;
}
#undef SIZES

Oder man speichert sich die Grösse auch noch irgendwo in der 
Datenstruktur ab. Kommt halt ganz drauf an, was man damit machen will.

[Rolf M. (rmagnus)]

Harald K. schrieb:
> Willst Du zur Laufzeit herausfinden, wie groß Deine Arrays sind, und das
> nur aus a[] heraus?
>
> Das könntest Du mit einem zusätzlichen Array erreichen:

Da man Arrays aus char eh nur für Text verwenden sollte, kann man dann 
auch gleich die in C übliche Nullterminierung verwenden und hat dann 
auch die Länge und kann die ganzen Stringfunktionen von C verwenden.

[Werner D. (werner_d350)]

Vielen Dank für die ganzen Antworten.
Ich habe es jetzt so gemacht wie Harald/Mikro 7/Michael es beschrieben 
hat. War am einfachsten in die bestehende Programmierung einzubinden ( 
Die war etwas umständlich)
Ich brauchte eine Funktion ähnlich der split-Funktion in JS und dazu 
brauche ich ein Array von char-Arrays (Strings).