# C Anfänger Beispiel



## C Programmierer (28. Dez 2009)

Hallo zusammen,

ich muss in folgendem Programm die Lücken die mit **** gekennzeichnet sind entsprechend ausprogrammieren.

Leider komme ich damit nicht zurecht und wollte fragen, ob mir jemand dabei behilflich sein kann.
Als Ergebnis soll "Frohe Weihnachten 2009" herauskommen.

Wäre nett, wenn mir hier jemand helfen könnte....danke.


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

int toggle = 1;
char* result;
int calcYear(int y2)
{
	int y = 0;
	for(int i = 0; i < ****;i++)
	{
		int z = 0;
		while(z < 400)
			z++;
		
		y += z;
	}

	for(int i = 1; i <****;i++)
	y++;

	do{y++;}
	while (toggle);

	return y + y2;
}

char* set(char* text)
{
	char t[5];
	sprintf(t,"ohreF");
	char* org = text;

	text[****] = t[4];
	text++;
	*text = t[2];
	text[1] = *t;
	text = text + (10/2) - ****;
	*text = t[1];
	text[****] = t[3];

	
	return org;
}

void writeXMAS()
{
	sprintf(result + ****,"Weihnachten");
}

int main()
{
	result = (char*)malloc(sizeof(char)*30);
	memset(result,' ',30);

	toggle = ****;
	set(result);
	writeXMAS();
	sprintf(result+****," %d",calcYear(1));
	
	
	result[29] = '\0';
	
	printf("%s \n",result);
	

	free(result);
	return 1;
}
```


----------



## Final_Striker (28. Dez 2009)

wo genau liegt dein problem???


----------



## C Programmierer (28. Dez 2009)

also habe den Quelltext kommentiert soweit ich das verstehe bzw. was eben nicht.


```
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
int toggle = 1;
char* result;
int calcYear(int y2) //y2 = 1;
{
    int y = 0;
    for(int i = 0; i < ****;i++)
    {
        int z = 0;
        while(z < 400) //Frage: wieso z < 400?
            z++;
        
        y += z;
    }
 
    for(int i = 1; i <****;i++)
    y++;
 
    do{y++;}
    while (toggle);
 
    return y + y2;
}
 
char* set(char* text)
{
    char t[5]; //deklarieren eines char arrays mit der Größe 5
    sprintf(t,"ohreF"); //initialiseren des char Array mit dem Zeichensatz "ohreF"
    char* org = text; //der org Zeiger verweist auf text ...also auf die selbe Adresse
 
    text[****] = t[4]; //erzeugen eines text array mit den ersten 4 Zeichen des t Arrays; würde hier text mit der Größe 4 erzeugen
    text++; //den Zeiger auf das nächste Element verweisen lassen ...Frage: wozu benötige ich dies?
    *text = t[2]; //der text Zeiger zeigt auf das 2 Element des t Arrays 
    text[1] = *t;  //die nächsten 4 Zeilen verstehe ich leider gar nicht
    text = text + (10/2) - ****;
    *text = t[1];
    text[****] = t[3];
 
    
    return org;
}
 
void writeXMAS()
{
    sprintf(result + ****,"Weihnachten"); //Frage: was soll diese Methode nun bewirken? 
}
 
int main()
{
    result = (char*)malloc(sizeof(char)*30);  //Speicherplatz reservieren für 30 Zeichen
    memset(result,' ',30); //befüllen bzw. überschreiben der ersten 30 Zeichen mit Leerzeichen; Frage: wofür ist das genau gut?
 
    toggle = ****; //weiß leider nicht auf was ich diese Variable setzen soll.
    set(result); //Aufruf der set Funktion mit Übergabe des result zeigers als Parameter
    writeXMAS(); 
    sprintf(result+****," %d",calcYear(1));  //Frage: was soll diese Methode nun bewirken? 
    
    
    result[29] = '\0';
    
    printf("%s \n",result);
    
 
    free(result); //Sepicher freigeben
    return 1;
}
```


----------



## Marco13 (28. Dez 2009)

Ein paar Kommentare zu den Kommentaren:

_text[****] = t[4]; //erzeugen eines text array mit den ersten 4 Zeichen des t Arrays; würde hier text mit der Größe 4 erzeugen_

Nein. An die Position **** von 'text' wird das zeichen geschrieben, dass in 't' an Position 4 steht.

_text++; //den Zeiger auf das nächste Element verweisen lassen ...Frage: wozu benötige ich dies?_

Damit in der nächsten Zeile an diese neue Position geschrieben wird

_*text = t[2]; //der text Zeiger zeigt auf das 2 Element des t Arrays _

Nein: Durch das "*" vor 'text' wird t[2] dort hin geschrieben, wo der Zeiger hinzeigt (also an die Stelle, an die der zeiger mit 'text++' verschoben wurde)

_die nächsten 4 Zeilen verstehe ich leider gar nicht_

```
text[1] = *t;  // An die Stelle 1 des (verschobenen!) text-Zeigers wird der Inhalt von 't[0]' geschrieben
    text = text + (10/2) - ****; // Verschiebe den 'text' Zeiger ein bißchen
    *text = t[1]; // An die stelle, wo 'text' jetzt hinzeigt, wird t[1] geschrieben
    text[****] = t[3]; // An eine Position des (verschobenen!) text-Zeigers wird der Inhalt von 't[3]' geschrieben
```
 


_sprintf(result + ****,"Weihnachten"); //Frage: was soll diese Methode nun bewirken? _

Schreibt das "Weihnachten" an die ****te Position von 'result'


_ memset(result,' ',30); //befüllen bzw. überschreiben der ersten 30 Zeichen mit Leerzeichen; Frage: wofür ist das genau gut?_

Ist vielleicht nicht unbedingt notwendig, aber ... wenn man den Text nicht ganz auffüllen würde, würde dort sonst irgendwelcher %&§$(&%43-Mist drinstehen.


_sprintf(result+****," %d",calcYear(1));  //Frage: was soll diese Methode nun bewirken? _

Schreibt das Jahr an die ****te Position von 'result'


Ein wichtiger Punkt zur Lösung und dem Verständnis ist wohl die Tatsache, dass Zeiger und Arrays in C in gewissen Grenzen "austauschbar" sind - unabhängig von Stil & Co ein illustrierendes Beispiel (obwohl ich aus C schon ein bißchen raus bin...)

```
char array[10];

char *pointer0 = array; // 'pointer0' Zeigt auf das array-element mit index 0
char *pointer0 = &array[0]; // Wäre das gleiche!

char *pointer3 = pointer0 + 3; // 'pointer3' zeigt jetzt auf das Array-Element mit index 3
char *pointer3 = &array[3]; // Wäre das gleiche!

*pointer0 = 'x'; // Schreibe 'x' an index 0 des Arrays
array[0] = 'x'; // Wäre das gleiche

*pointer3 = 'y'; // Schreibe 'y' an index 3 des Arrays
array[3] = 'y'; // Wäre das gleiche

*(pointer0 + 5) = 'z'; // Schreibe 'z' an index 5 des Arrays
array[5] = 'z'; // Wäre das gleiche
```

Die Begründung dafür ist recht einleuchtend: Es gilt 

```
array[x] == *(array+x)
```
Das 'array[x]' ist nur eine einfachere, bequemere Schreibweise.

Wenn man jetzt noch berücksichtigt, dass [c]a+b == b+a[/c] gilt, kommt man darauf, dass tatsächlich

```
array[x] == *(array+x) == *(x+array) == x[array]
```
gilt.

Kannst deinen Lehrer ja ein bißchen ärgern, und nur zum Spaß solche Frickeleien wie

```
char array[5];
sprintf(array,"ohreF");
int index = 4;
[b]char F = index[array];[/b]
```
verwenden


----------



## C Programmierer (28. Dez 2009)

danke für deine ausführliche Erklärung


----------

