C, Pointer usw.
 

Hallo,

habe leider noch nicht sehr oft C Programmiert (eher Java > keine Pointer!) und kenne mich deswegen nicht wirklich mit Pointern aus könntet ihr mir vielleicht mal bei dem kleinen proggi helfen?


wenn man die werte für die seiten eingibt dann den pointer auf die adresse dieser werte übergibt dort dann int X = *Y kommt ein anderer Wert als der den man eingegeben hat...


vermutlich ist das ein ganz dummer fehler aber ich wäre echt dankbar wenn ihr mir sagen könntet was ich falsch machen!
DANKE
lg
S@ndy!


************************************************** *******
#include <conio.h>
#include <stdio.h>

int ordnen (int*, int*,int*, int*,int*, int*);
int ueberpruefen (int*, int*,int*, int*,int*, int*);


void main()

{

int v_schachtel1[3] = {0, 0, 0} , v_schachtel2[3] = {0, 0, 0};
int* p_seite_1_a = &v_schachtel1[0];
int* p_seite_1_b = &v_schachtel1[1];
int* p_seite_1_c = &v_schachtel1[2];
int* p_seite_2_a = &v_schachtel2[0];
int* p_seite_2_b = &v_schachtel2[1];
int* p_seite_2_c = &v_schachtel2[2];


printf ("Herzlich Willkommen zum Schachtelberechnungsprogramm\n");

printf ("\nBitte geben sie die 1 Seite der 1 Schachtel ein: ");
v_schachtel1[0] = getche();
printf ("\nBitte geben sie die 2 Seite der 1 Schachtel ein: ");
v_schachtel1[1] = getche();
printf ("\nBitte geben sie die 3 Seite der 1 Schachtel ein: ");
v_schachtel1[2] = getche();



printf ("\nBitte geben sie die 1 Seite der 2 Schachtel ein: ");
v_schachtel2[0] = getche();
printf ("\nBitte geben sie die 2 Seite der 2 Schachtel ein: ");
v_schachtel2[1] = getche();
printf ("\nBitte geben sie die 3 Seite der 2 Schachtel ein: ");
v_schachtel2[2] = getche();


ordnen (p_seite_1_a, p_seite_1_b, p_seite_1_c, p_seite_2_a, p_seite_2_b, p_seite_2_c);


}

int ordnen (int* p_seite_1_a, int* p_seite_1_b, int* p_seite_1_c, int* p_seite_2_a, int* p_seite_2_b, int* p_seite_2_c)
{
int v_seite_1_a = *p_seite_1_a;
printf ("\n%d\n", v_seite_1_a);
int v_seite_1_b = *p_seite_1_b;
printf ("\n%d\n", v_seite_1_b);
int v_seite_1_c = *p_seite_1_c;
printf ("\n%d\n", v_seite_1_c);
printf ("\nSchachtel1 : %d, %d, %d \n", p_seite_1_a, p_seite_1_b, p_seite_1_c);
getch();
ueberpruefen(p_seite_1_a, p_seite_1_b, p_seite_1_c, p_seite_2_a, p_seite_2_b, p_seite_2_c);
return 0;
}

int ueberpruefen (int* p_seite_1_a, int* p_seite_1_b, int* p_seite_1_c, int* p_seite_2_a, int* p_seite_2_b, int* p_seite_2_c)
{
printf ("\nSchachtel1 : %d, %d, %d \n", p_seite_2_a, p_seite_2_b, p_seite_2_c);
getch();
return 0;
}
************************************************** ******************:confused: :confused:

Sag hast du ein Buch oder sowas zum Lernen, weil die Pointer gschicht is ziemlich heftig, besonders wenn man von einer OOP Sprache kommt, würd ich mal sagen.

Ich hab das Proggy mal so durchgschaut, und ein paar grundlegende Fehler entdeckt, sofern ich mich ned täusche (hab jetzt auch schon seit einem halben Jahr nicht mehr in C programmiert). Pointer hier zu erklären wäre einfach zu lang, deshalb geb ich dir hier ein paar links zu Seiten die dir weiterhelfen können:

Deutsches C Tutorial
Ich kann dieses Tutorial nur weiterempfehlen. Es ist sehr einfach und wirklich ausführlich. Sollte man etwas mal wirklich nicht verstehen kann man den Webmaster mailen, und der beseitigt dann die restlichen Unklarheiten, und updated seine Erklärungen dann eventuell sogar.

A TUTORIAL ON POINTERS AND ARRAYS IN C
Der letzte Link ist sehr ausführlich und gut, lass dich aba nicht abschrecken von den anderen Kapiteln. Wenn du etwas noch nie gehört hast dann lass es lieber und schau es dir später nochmal an wenn du es in grundsätzlichen Zügen verstanden hast, z.B.: wenn du noch nie etwas von strukturen gehört hast dann vergeude deine zeit nicht damit dieses Kapitel zu lesen, denn dann wird die C nie richtig begeistern obwohl es einen tolle und mächtige Sprache ist. Wenn du merkst du checkst absolut nichts dann leg es beseite und lies zuerst die Erklärungen des ersten Links.

So und hier ist noch eine ganz gute Linksammlung...

So hoffe ich konnte dir weiterhelfen...

PredeX

Zeiger sind Variablen. Ganz spezielle Variablen. In ihnen werden keine Datenwerte sondern Speicheradressen hinterlegt. Um an die Datenwerte an diesen bzw. dieser Speicheradresse(n) heranzukommen muß man den * Operator unmittelbar vor dem Variablennamen des Zeigers angeben. Resultieren tut das ganze dann in dem Datentyp, auf den der Zeiger zeigt und so definiert wurde. Die Definition erfolgt ebenso mit Datentyp *zeiger;

Deklaration:

int datenvariable,*zeigervariable;

Definition:

int funktion (int datenparameter, int *zeigerparameter)


Typdefinition:

typedef <bekannter Datentyp/Strukturdefinition> * zeigertyp,datentyp;

z.B.: typedef char * zeiger_auf_char;

und in weiterer Folge bei der Deklaration: zeiger_auf_char pChar;

pChar ist eine Zeigervariable vom Typ char *

Um den Datenwert der Speicheradresse bzw. des Speicherbereichs zu erhalten / zu setzen, auf den die Zeigervariable weist, muß man mittles * zeiger zugreifen.

int ch,*pChar;

pChar= &ch;

& (=Ampersand) ist der Adreßoperator. Die Datenvariable ch wird an einer Speicherstelle vorgehalten. Die Adresse dieser Speicherstelle ermittelt man mit dem "Address of" - Operator &.

*pChar= 'a'; /* pChar muß auf ch zeigen ! */

printf("Zeichen in ch: %c\n",ch);

Arithmetik:

typedef struct {
int var1,var2;
long var3,var4;
} typstrukt1;

typstrukt1 strukt_MAXI[2],*zeiger_auf_strukt_MAXI_vom_typ_typstrukt1;

zeiger_auf_strukt_MAXI_vom_typ_typstrukt1= &strukt_MAXI[0];

for(i=0;i<2;i++,zeiger_auf_strukt_MAXI_vom_typ_typ strukt1++)
{
zeiger_auf_strukt_MAXI_vom_typ_typstrukt1->var1=1;
zeiger_auf_strukt_MAXI_vom_typ_typstrukt1->var2=2;
zeiger_auf_strukt_MAXI_vom_typ_typstrukt1->var3=3;
zeiger_auf_strukt_MAXI_vom_typ_typstrukt1->var4=4;
}


Erklärung zur Arithmetik:

" zeiger_auf_strukt_MAXI_vom_typ_typstrukt1++ " bedeutet den Inhalt der Zeigervariablen um die Größe des Datentyps, auf den die Zeigervariable weist, zu erhöhen.

Wenn man die Länge des Datentyps typstrukt1 mit 12 Bytes annimmt (je 2 Bytes für var1 und var2 sowie 4 Bytes für var3 und var4) so erhöht sich der Wert (=die Speicheradresse) in zeiger_auf_strukt_MAXI_vom_typ_typstrukt1 nicht um 1 sondern um 12.

Wenn man zeiger_auf_strukt_MAXI_vom_typ_typstrukt1+=2; schreibt, so erhöht sich der Wert in zeiger_auf_strukt_MAXI_vom_typ_typstrukt1 nicht um 2 sondern um 2*12 = 24.

Arrays versus Zeiger:

Arrays sind feste Zeiger, die keine L-Werte (Linksseitige Zuweisungswerte) annehmen können.

int array_von_ints[100]; /* Index geht von 0 bis 99 !!! */

int intvariable;

int *zeiger_auf_arrayelement,*zeiger_auf_arrayelement_ nein_einzelnen_intwert;

zeiger_auf_arrayelement= array_von_ints;
zeiger_auf_arrayelement_nein_einzelnen_intwert= &intvariable;

Im zweiten Fall braucht man das Ampersand (-> & <-), im ersten nicht, weil array_von_ints bereits ein (fester) Zeiger - und damit keine Datenvariable - ist.

mfg
Kikakater

Danke
 

Vielen Danke für die ausführliche Erklärung
und vielen dank für die links...

hm ich weiss ich muss noch sehr viel lernen - aber es wird schon - es daugt mir ja total - in der arbeit arbeite ich mit einer modifizierten sprache - da ist alles ganz anders - vielleicht mach ich deshalb jetzt in c auch einige fehler rein.... aber übung macht den meister... *G* also üb ich mal weiter...

lg
S@ndy