C - Übergabe und Verwendung Tabelle

[Dietmar P. (dietmar2)]

Hallo,

für Anzeige eines Textes in einem Display (funktioniert mit Atmega32 mit 
der Funktion lcd_string bereits)
möchte ich Texte in einer Tabelle (array) definieren und über einen 
Index eine Zeile im Display anzeigen.

Ziele war die Anzeige mit

lcd_string (obj[i]);

Probiert habe ich:

main
.
.
  char obj[3][10] = {" "};  // Definition Tabelle Objekte
.
.
  initobj (&obj)                // Übergabe Tabelle für init
.
  printf ("%s \n", obj[1]);     // Test einer Zeile

//Ende main

01 // initobj                  // Initialisieren der Tabelle
.
05 void initobj(char *pobj) 
.
12    char *pobj[3][10] = {
13      "Zeile 1",
14      "Zeile 2",
15      "Zeile 3"
16            }
17 //Ende initobj

Fehler:

initobj.c:12:10: Fehler: »pobj« als andere Symbolart redeklariert
initobj.c:5:20: Anmerkung: Vorherige Definition von »pobj« war hier

Habe es auf dem PC probiert und kriege es nicht hin.
Bitte um einen Tipp von den C-Profis wie man das richtig macht.

Danke, Gruß

[Noname (Gast)]

Naja. Der Compiler wundert (sic) sich warum Du einen Parameter noch 
einmal als lokale Variable deklarierst.

[Joachim D. (Firma: JDCC) (scheppertreiber)]

Dietmar P. schrieb:
> char *pobj[3][10] = {
> 13      "Zeile 1",
> 14      "Zeile 2",
> 15      "Zeile 3"
> 16            }


Einfach nur pobj so definieren:

char *pobj[] = { "Zeile 1", "Zeile 2", "Zeile 3", NULL };

zB dann ausdrucken:

int i;
for ( i=0; pobj[i] != NULL; i++)
  printf( pobj[i]);

[Karl H. (kbuchegg)]

Viel einfacher als du denkst

  char obj[3][10] = {
    "Zeile 1",
    "Zeile 2",
    "Zeile 3"
  };

die ganze Funktion "initobj" brauchst du gar nicht.

[Dietmar P. (dietmar2)]

OK,

danke für Eure Anregungen, werde einmal weiter testen mit Euren 
Hinweisen.

Gruß

[Dietmar P. (dietmar2)]

Hallo,

muss doch nochmals um Hilfe bitten.

Habe die Tabelle im main definiert, ist ok.

Der Zugriff darauf soll allerdings in einem Unterprogramm erfolgen und 
das gelingt mir nicht.

Meine bereitsbestehende Anwendung ist schon umfangreich und 
strukturiert, sodass ich die Verarbeitung der Tabelle nicht im main 
machen sollte.

Versuch:

main
.
  char obj[3][10] = {"Zeile 1", "Zeile 2", "Zeile 3"};
.
  objekte(&obj)
.
// Ende main

01 // Test Objekte
02 void objekte(char *pobj) 
03 {
04    printf ("%s \n", *pobj[2]);  // Test anzeigen Zeile 2
05 }
06 // Ende Test

Fehler:

objekte.c: In Funktion »objekte«:
objekte.c:4:5: Warnung: Unverträgliche implizite Deklaration der 
eingebauten Funktion »printf« [standardmäßig aktiviert]
objekte.c:4:22: Fehler: ungültiger Argumenttyp in unärem »*« (haben 
»int«)

Kann ich die Tabelle zur Verarbeitung nicht wie sonst eine Variable mit 
dem Pointer übergeben?
Wo liegt mein Fehler?
Mit NULL kam ich nicht klar.

Danke für Eure Hilfe!
Gruß

[Joachim D. (Firma: JDCC) (scheppertreiber)]

Na jam nach Dir einfach mal klar was Du definiert hast:

obj besteht aus 3 Arrays (die Schreibweise ob[3][10] halte ich
für unglücklich gewählt, ich würde es wie in meinem Beispiel
definieren - dann ist es klarer) mit je 10 Byte.

obj[0] ist die Adresse des ersten Arrays, diese sollstest Du an
objekte übergeben und direkt ausgeben. Also

objekte( obj[0]);
objekte( obj[1]);
...

02 void objekte(char *pobj) 
03 {
04    printf ("%s \n", pobj);  // Test anzeigen Zeile 2
05 }

[morgenmuffel (Gast)]

Dietmar P. schrieb:
> 04    printf ("%s \n", *pobj[2]);  // Test anzeigen Zeile 2

04 printf ("%s \n", pobj[1][0]);

zeiger auf arrays

[Dietmar P. (dietmar2)]

Also kann ich nicht ein mehrdimensionales array übergeben und dann im 
Unterprogramm darauf "zeilenweise" zugreifen?

[Udo S. (urschmitt)]

Dietmar P. schrieb:
> Also kann ich nicht ein mehrdimensionales array übergeben und dann im
> Unterprogramm darauf "zeilenweise" zugreifen?

Kann man schon, aber schau mal WAS GENAU du übergibst:

void objekte(char *pobj)

Ist "char *pobj" denn ein mehrdimensionales Array?
Du hast die Funktion objekte so definiert daß du ihr einen String 
(character Array) übergibst, aber nicht so daß du ihr ein 2 dim. char 
Array übergibst.

2. Fehler:
Du rufst die Funktion so auf:
  objekte(&obj)

Jetzt ist aber der Name eines Arrays in C per se schon eine 
Adressvariable. Wenn du die nochmal mit dem Adressoperator referenzierst 
dann übergibst du der Funktion einen Zeiger auf die Adresse eines 
2dimensionalen Arrays. Das ist aber nicht das was du willst.

Die in der Funktion übergebene Variable und die in der 
Funktionsdefinition definierte Variable müssen vom gleichen Typ sein.

Ich würde vorschlagen daß du einen char * (Einen Zeiger auf den String) 
statt ein Array von Strings) übergibst und dann entsprechend mit einem 
Element deines Stringarrays aufrufst.

[morgenmuffel (Gast)]

// Test Objekte
 void objekte(char *pobj[])
 {
    printf ("%s \n", pobj[1]);  // Test anzeigen Zeile 2
 }
 // Ende Test




int main()
{
  char *obj[] = {"Zeile 1", "Zeile 2", "Zeile 3"};

  objekte(obj);
return 0;
// Ende main
}

so klappts bei mir
ja zeiger und arrays sind für mich etwas verwirrend.

[Udo S. (urschmitt)]

morgenmuffel schrieb:
> ja zeiger und arrays sind für mich etwas verwirrend.

Mehrdimensionale Arrays sind in C auch nicht unbedingt einfache Kost.

[Dietmar P. (dietmar2)]

Bei mir gehts leider nicht.

Habe genau dieses Beispiel mal übernommen und bekomme folgenden Fehler:

objekte.c:4:5: Warnung: Unverträgliche implizite Deklaration der 
eingebauten Funktion »printf« [standardmäßig aktiviert]

[Udo S. (urschmitt)]

Dietmar P. schrieb:
> Warnung: Unverträgliche implizite Deklaration der eingebauten Funktion »printf«
Schon mal den Fehler genau angeschaut?
Sieht aus als hättest du printf noch mal deklariert und zwar anders als 
im header.

Zeig mal dein Code

[Klaus W. (mfgkw)]

oder gar nicht deklariert.
(Steht zwar in jedem C-Buch, wie es geht, aber wozu gibt es das Forum?)

[Dietmar P. (dietmar2)]

printf habe ich nicht (re-)definiert, ich habe es verwendet wie es in 
den Bibliotheken steht. Compiler ist gcc für den PC und Avr-gcc für den 
Atmega32.
Code nur für Testzwecke des array:

 // Main
 
#include <stdio.h>
#include "stdint.h"
#include <string.h>  


void main(void)
{

  char *obj[] = {"Zeile 1", "Zeile 2", "Zeile 3"};

  objekte(obj);
//return 0;

} // Ende main


// Test
 void objekte(char *pobj[])
 {
    printf ("%s \n", pobj[1]);  // Test anzeigen Zeile 2
 }
// ende

Der ganze Code ist recht komplex und beinhaltet eine komplette Steuerung 
einer Leitungsauswertung und Anzeige per SPI.

[Mittesser (Gast)]

Wenn man einen Zeiger auf ein mehrdimensionales Array übergeben will, 
sollte die aufgerufene Funktion schon "wissen", wie groß die inneren 
Dimensionen sind.

#include <stdio.h>
#include <string.h>

void EineFunktion(char Parameter[][10])
{
        int i;
        for (i=0; i<3; i++)
        {
                printf ("%s \n", Parameter[i]);
        }
}

int main(int argc, char** argv)
{
        char Textzeilen[3][10];
        memset(Textzeilen, 0, sizeof(char[3][10]));
        strcpy(Textzeilen[0], "1te Zeile");
        strcpy(Textzeilen[1], "2te Zeile");
        EineFunktion(Textzeilen);
        return 0;
}

Wenn man das etwas lesbarer und weniger geschwätzig machen will, kann 
man mit Typendefinitionen arbeiten:

#include <stdio.h>
#include <string.h>

typedef char Zeile_t[10];
typedef Zeile_t Dreizeiler_t[3];

void EineFunktion(Dreizeiler_t Parameter)
{
        int i;
        for (i=0; i<3; i++)
        {
                printf ("%s \n", Parameter[i]);
        }
}

int main(int argc, char** argv)
{
        Dreizeiler_t Textzeilen;
        memset(Textzeilen, 0, sizeof(Dreizeiler_t));
        strcpy(Textzeilen[0], "1te Zeile");
        strcpy(Textzeilen[1], "2te Zeile");
        EineFunktion(Textzeilen);
        return 0;
}

[Dietmar P. (dietmar2)]

Danke für die ausführliche Beschreibung.

Jetzt habe ich die Lösung.