C: dynamischer Variablenname

[Michael N. (garril)]

Hallo,

mein Ursprungsproblem:
Ich möchte ein Array mit 8 Unterarray, welche aber verschiedenviele Wert 
haben können.
D.h.
array mit einer Größe von 8
array[8]
Untearray0 mit 100 Werten:
array[0][100]
Untearray1 mit 50 Werten:
array[1][50]
Da das soweit ich weiß nicht funktioniert, müsste ich alle Unterarray 
gleichgroß machen (eben so groß wie das größte).
--> array[8][100]
Leider braucht das zu viel Speicher...

Nun meine Überlegung:
array0[100]
array1[50]

Nur wie bekomme ich es hin, wenn ich zB in der Variable int i = 1 stehen 
habe, dass ich dann auf array1 zugreifen kann??

int i = 1;
int array1[50]={123, 456};
int test;

test=array+i[0]; //test soll der Wert "123" zugewiesen werden...

Gerade schon etwas Hilfe im Chat bekommen, klappt aber immer noch 
nicht...

int i=1;
char *str=malloc(255);
strcat (str, "pattern");
strcat (str, (char)i);
serpa[0]=str; //In serpa[0] soll der Wert aus pattern1 geschrieben werden

Kennt jemand den richtigen Weg zum Ziel?

[Markus W. (Firma: guloshop.de) (m-w)]

Hallo!
Kurze Rückfrage: Ändern sich die Längen der einzelnen Zeichenketten 
später, oder bleiben sie konstant?

[Noname (Gast)]

>Kennt jemand den richtigen Weg zum Ziel?
Klar. Lies ein C-Buch.

[asad (Gast)]

Bin mir jetzt nicht so ganz sicher was du vorhast, trotzdem mal ein 
Codeschnipsel:

int subarray1[50], subarray2[100], subarray3[42];
int *array[3]={subarray1, subarray2, subarray3};

array[0][10]=42;

[Emperor_L0ser (Gast)]

Naja, mit Pointern sollte das gehen:

char * top_array[8];

char array0[100] = "viel text ....";
char array1[20] = "weniger..";
...


top_array[0] = array0;
top_array[1] = array1;

printf("Zeichen: %d\n", top_array[0][10]);

viele Grüße

[Michael N. (garril)]

Ahhhhh
Einfach ein Array mit Pointern auf die "Unterarrays" anlegen.
Werde das gleich mal probieren, aber das sollte natürlich funktionieren 
und ist eine super elegante Lösung

[Markus W. (Firma: guloshop.de) (m-w)]

Michael N. schrieb:

> int i=1;
> char *str=malloc(255);
> strcat (str, "pattern");
> strcat (str, (char)i);
> serpa[0]=str; //In serpa[0] soll der Wert aus pattern1 geschrieben
> werden

"strcat()" ist eine Funktion, die relativ viel Zeit benötigt, nicht 
unbedingt zu empfehlen, wenn das Programm möglichst schnell laufen soll 
oder wenn man es auf einem uC einsetzt.

Wenns also zu Laufzeitproblemen kommt, schau dir mal "stpcpy()" an.

> In serpa[0] soll der Wert aus pattern1 geschrieben werden

Was meinst du damit? Was ist der "Wert aus pattern1"? Beispiel?

[Michael N. (garril)]

Also nun läuft es. VIELEN DANK!
Um nochmal das Problem genau aufzuzeigen, hier die Lösung:

uint8_t pattern0[10]={0b10000001};
uint8_t pattern1[10]={0b10100101};
uint8_t pattern2[10]={0b00011000};
uint8_t * pattern_pointer[3]={pattern0,pattern1,pattern2};

int i=0;
//Bits werden je nach Wert in int aus dem passenden pattern gelesen und ausgegeben (Schieberegister)
serpa[0]=pattern_pointer[i][0];
serpa_out();

Super, danke für die schnelle Hilfe

[Johannes G. (gutenberg)]

Das Beispiel versteh ich jetzt nicht ganz. Du hast da drei Byte in drei 
Arrays a je 10 Byte gespeichert. Wieso das?

[Michael N. (garril)]

Die werden natürlich noch erweitert ;)

Das läuft so ab: (sind Daten für ein Schieberegister an dem LEDs hängen)
pattern0[0] anlegen, 500 ms warten
pattern0[1] anlegen, 500 ms warten
pattern0[2] anlegen, 500 ms warten
pattern0[3] anlegen, 500 ms warten
...usw...
Wenn das Ende erreicht ist, wieder von vorne anfangen.

Auf Tastendruck kann man dann von pattern0 auf pattern1 umschalten.
Also dann:
pattern1[0] anlegen, 500 ms warten
pattern2[1] anlegen, 500 ms warten
pattern3[2] anlegen, 500 ms warten
pattern4[3] anlegen, 500 ms warten
...usw...

Und weil nicht alle patterns gleichlang sind, war eine Lösung per 
mehrdimensionalem Array nicht möglich :)

Denke das macht Sinn, oder?

[Karl H. (kbuchegg)]

Michael N. schrieb:

> Und weil nicht alle patterns gleichlang sind, war eine Lösung per
> mehrdimensionalem Array nicht möglich :)
>
> Denke das macht Sinn, oder?


Die Grundidee ist schon klar.
Jetzt kommt aber die Preisfrage:
Woher weiß dein Code, wie lang das jeweilige Unterarray ist?

Im Moment ist es leicht. Sind alle 10 Einträge lang. Aber davon wolltest 
du ja weg.

Edit: Ich sag nicht das es unmöglich ist. Es ist definitiv möglich, 
dieses 'Problem' zu lösen. Es ist noch nicht mal besonders schwer, wenn 
man den Gedankengang eines 2D-Arrays über Bord wirft und sich erst mal 
klar macht, dass man eine Beschreibung für ein Ausgabemuster benötigt. 
Jedes Muster besteht aus einer Längenangabe und einem Datenfeld 
(variabler Länge).

Die Sammlung aller Ausgabemuster ist dann ein Array von Ausgabemustern.

Und diese Sichtweise ist dann schon relativ weit von der Sichtweise des 
"Ich brauche ein 2D Array mit variablen Längen" entfernt

1 Muster:

struct Pattern
{
  uint8_t  Length;
  uint8_t* Data;
}

die Daten zu 2 Muster

uint8_t Pattern1[] = { 0x10, 0x20, 0x30 };
uint8_t Pattern2[] = { 0x40, 0x80, 0x56, 0x83 };

das Array mit allen Ausgabmustern

struct Pattern AllPatterns[] =
  { sizeof( Pattern1 ), Pattern1 },
  { sizeof( Pattern2 ), Pattern2 }
};

[M. L. (erf)]

Hi,

ich versteh das nicht.
Wieso legst du ein Array mit 10 Elementen vom Typ uint8_t (unsigned 
char) an und schreibst genau 1 byte hinein?

> uint8_t pattern0[10]={0b10000001};

Wozu also das Array? Warum nicht einfach

uint8_t pattern0 = 0b10000001;

[M. L. (erf)]

Michael N. schrieb:
> Die werden natürlich noch erweitert ;)

Ach das hatte ich überlesen!

Dank Karl Heinz Buchegger ist mir jetzt auch klar was der TO wollte ;)..

[c-- (Gast)]

>Klar. Lies ein C-Buch
Warum wird bei C-Fragen immer auf ein C-Buch verwiesen ?

[Karl H. (kbuchegg)]

c-- schrieb:
>>Klar. Lies ein C-Buch
> Warum wird bei C-Fragen immer auf ein C-Buch verwiesen ?

Aus dem gleichen Grund, aus dem dir ein Polizist bei einer 
Verkehrskontrolle auf dein Schulterzucken bei der Frage nach der 
Bedeutung eines 8 eckigen, hautsächlich roten Schildes, den Besuch einer 
Fahrschule dringenst und mit Nachdruck nahelegen wird.

Die Grundlagen lernt man nun mal nicht durch Sammeln von anlassbezogenem 
Halbwissen, sondern in dem einem jemand systematisch durch die 
Grundlagen durchführt.

Im Strassenverkehr ist das die Fahrschule (mit entsprechenden Kosten). 
In der Programmierung ist das die Literatur (mit im Vergleich moderaten 
Kosten)

[Michael N. (garril)]

Um die Länge des Arrays zu "kennen" werde ich einfach als erstes 
Arrayelement die Länge übergeben.
Dann kann ich beim durchspringen der Patterns einfach mit array[1] statt 
[0] beginnen.
Ansonsten müsste es natürlich mit sizeof(Pattern1)/(Länge eines Wertes, 
also 8 Bit) eigentlich auch gehen.

Weil oben auf ein C-Buch verwiesen wurde: Das hätte mir auch nicht 
großartig geholfen, da ich nicht auf die Logik gekommen bin, die Pointer 
zu den Unterarrays in ein weiteres Array zu schreiben.
Für Buchvorschläge bin ich trotzdem jederzeit offen.

[Karl H. (kbuchegg)]

Michael N. schrieb:
> Um die Länge des Arrays zu "kennen" werde ich einfach als erstes
> Arrayelement die Länge übergeben.

Ergo: hacken von der üblen Sorte mit programmiererunterstütztem 
Fehlerpotential.

Angst vor Strukturen?

[Michael N. (garril)]

Noch nie benutzt, deshalb: ein bisschen

[Noname (Gast)]

Dankeschön, Karl Heinz. :-}

[abc123 (Gast)]

Michael N. schrieb:
> Für Buchvorschläge bin ich trotzdem jederzeit offen.

Kernighan & Ritchie: The C Programming Language, second edition