1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:

<?php #include <stdio.h>

int read_int (char w00t []) {
    int tmp;
    printf (w00t);
    do {
        scanf ("%d", &tmp);
    } while (getchar () != '\n');
    return tmp;
}

char read_char (char w00t []) {
    char tmp;
    printf (w00t);
    do {
        scanf ("%c", &tmp);
    } while (getchar () != '\n');
    return tmp;
}

int main () {
    char test [] = "Die Groeße passt sich automatisch an.";
    char *pointer = test; /* test == &test [0] */
    int change;
    char ch;

    for(; *pointer; ++pointer)
        printf ("%c", *pointer);

    printf ("\n");

    printf ("Welche Stelle moechten Sie veraendern? \n");
    change = read_int ("Stelle: ");

    printf("Welchen Buchstaben wollen Sie stattdessen einsetzen? \n");
    ch = read_char ("Buchstabe: ");

    pointer = test;
    *(pointer+change) = ch;

    for(pointer=test; *pointer; ++pointer)
        printf("%c",*pointer);

    printf ("\n");

    return 0;
} ?>

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

<?php for(durchlauf=0;durchlauf<=anzahl-1;durchlauf++)
                {                                          
                  for(hilfe=0,index=0;/*GEHT1*/index<=anzahl/*ZUWEIT;)*/;index++)
                   {
                    if(int1[durchlauf]>int1[index])
                     {
                              hilfe=int1[durchlauf];
                              int1[durchlauf]=int1[index];
                              int1[index]=hilfe;
                     }
                    }
                 } ?>

1:
2:
3:
4:
5:

struct myLinkedList { 
	int data; 
	myLinkedList *prev; 
	myLinkedList *next; 
};

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

struct myLinkedList *x,*anfang; 
x=(myLinkedList*)calloc(1,sizeof(myLinkedList ));
x->data=0x0815; 
x->next=(myLinkedList*)calloc(1,sizeof(myLinkedList ));
anfang=x;
x=x->next;
x->data=0xF00;
/*
...etc...
*/

1:
2:
3:
4:
5:
6:
7:

struct IPaddr
{ 
	unsigned int d:8; 
	unsigned int c:8; 
	unsigned int b:8; 
	unsigned int a:8; 
};

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

struct IPaddr *eineIP;
unsigned int *langeIP;
eineIP=(struct IPaddr*)calloc(1,sizeof(struct IPaddr ));
langeIP=(unsigned int)eineIP;
eineIP->a=192;
eineIP->b=168;
eineIP->c=1;
eineIP->d=1;

printf("%u\n",*langeIP);
*langeIP=3232235778;
printf("%u.%u.%u.%u\n",eineIP->a,eineIP->b,eineIP->c,eineIP->d);

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:

#define _ERR_ALLOC_FAIL "konnte nicht genügend Speicher reservieren(%s)\n"
#define _ERR_SOMETHING_ELSE "blah (%s)\n"

void err(const char msg, const char param)
{
        fprintf (stderr, msg, param);
        abort();
}

/*
.
.
.
*/
/*fehlerfall*/
    if (to_sort == NULL) 
	err(_ERR_ALLOC_FAIL,"main():5");

1:

do{ scanf("%d",&int1[index]);}while(getchar()!='\n');

1:
2:

/* Die äußere Schleife, diese ändert den Wert des ersten zeigers um eins */
               for(durchlauf=0;durchlauf<=anzahl-1;durchlauf++)

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:

/************************************************************ 
 * ein script, das den inhalt einer stringvariablen umdreht * 
 *        (ja, ich hab was gegen orthographie)              * 
 *        (arbeitet hauptsaechlich mit zeigern)             *
 *               21.08.2007 by Singh                        *
 ************************************************************/
 
#include <stdio.h>

/* Wir benötigt, wenn man den String manuell eingeben will
#define LENGTH 100
*/
 /*Prototyp*/
void turn_text(char *);

int main()
{
/* Die Stringvariable, mit [LENGHT] deklarieren, falls man sie manuell eingeben will */
char txt[]/*[LENGTH]*/="Fischers Fritz faengt frische Fische";

/* Die Funktion aufrufen, mit der startadresse der Stringvariablen txt == &txt[0] */ 
turn_text(txt); 

/* Da die Stringvariable mit hilfe ihrer Adresse geändert wird, kann sie global benutzt werden */
printf("%s",txt);
}


void turn_text(char *pt_txt/*Der Pointer zeigt auf den Anfang des Strings*/)
{
char hilfe,*pt_end;
pt_end=pt_txt; 

/*Und deiser wird ans Ende geschoben */
for(;*pt_end;pt_end++) {}

/* Jetzt tauschen jeweils zwei Arrayelemente die Plätze, bis sich die beiden Pointer in der Mitte treffen */
for(pt_end-=3;pt_txt<pt_end ;pt_txt++,pt_end--)
{

hilfe=*pt_txt;
*pt_txt=*pt_end;
*pt_end=hilfe;
}

}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

/************************************************************ 
 * ein script, das den inhalt einer stringvariablen umdreht * 
 *        (ja, ich hab was gegen orthographie)              * 
 *                                                          *
 *               21.08.2007 by Singh                        *
 ************************************************************/
 
#include <stdio.h>


//#define LENGTH 100



int main()
{
int index,len,index2;
char txt[]/*[LENGTH]*/="Fischers Fritz faengt frische Fische",hilfe,*pt_anfang,*pt_ende;
for(pt_ende=txt;*pt_ende!='\n';pt_ende++){ }
pt_anfang=txt;
len=(--pt_ende)-pt_anfang;


for(index=0,len-=3;index<len;index++,len--)
{
hilfe=txt[index];
txt[index]=txt[len];
txt[len]=hilfe;
}
printf("\n%s",txt);
}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

int main()
{
short anzahl;
struct wagen pkws[anzahl+1];
struct wagen *pointer;
pointer=&pkws[0];
printf("Wie viele Autos wollen sie speichern  ");
do{scanf("%d",&anzahl); } while(getchar()!='\n');
printf("Bitte machen sie Eingaben fuer %d Autos",anzahl);
eingabe(pkws,anzahl);
printf("\nSie haben folgende Daten angegeben");
ausgabe(pointer,anzahl);
}

1:
2:
3:
4:
5:
6:
7:
8:
9:

void ausgabe(struct wagen *pointer,short anzahl)
{
for(;pointer->abbruch!=-1;pointer++)
{

printf("\nDie Daten der Autos");
printf("Name %s Tempo %f Zylinder %d PS %d Benzin %c",pointer->name,pointer->speed,pointer->zylinder,pointer->ps,pointer->gas);
}
}

1:
2:
3:
4:
5:
6:
7:
8:

short anzahl;
struct wagen pkws[anzahl+1];
struct wagen *pointer;
pointer=&pkws[0];
printf("Wie viele Autos wollen sie speichern  ");
do{scanf("%d",&anzahl); } while(getchar()!='\n');
printf("Bitte machen sie Eingaben fuer %d Autos",anzahl);
eingabe(pkws,anzahl);

1:
2:
3:
4:
5:
6:

short anzahl;
printf("Wie viele Autos wollen sie speichern  ");
do{scanf("%d",&anzahl); } while(getchar()!='\n');
struct wagen *pointer;
struct wagen pkws[anzahl+1];
pointer=&pkws[0];

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:

int main()
{
struct wagen *pointer; /*zeigt iwo ins niwo */
int anz;
printf("Wie viele Wagen  ");
scanf("%d",&anz);

/* Und jetzt forder ich so viel Speicher an wie benötigt, in form eines arrays, und setzte den pointer an dessen anfang */

pointer=malloc(anz*sizeof(struct wagen));
/* Wenn nicht genug Speicher da ist */
if(!pointer) 
{
printf("Tot und verderben");
return 0;
}
/* dann übergebe ich den pointer an die funktion */
eingabe(pointer,anz);
/* und am ende */
free(pointer);
return 0;
}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:

/************************************************************** 
 *                       auto.c                               *       
 *   Speichert die Daten von Autos in einer Struktur.         *
 *   Bentuzt ausschließlich Zeiger auf Variablen und          *
 *   reserviert den benötigten Speicher mit der funktion      *
 *   malloc zu laufzeit nach "benutzerdefinierten kriterien"  *
 *   erstellt am 21.08.2007 by Singh                          *
 **************************************************************/

#include <stdio.h>

#define MAXLEN 20

/******************************
 Definition der Struktur
 ******************************/

struct wagen {
char name[MAXLEN];    /* Name des Autos */
float speed;          /* Geschwindigkeit */
int zylinder;         /* Anzhl der Zilynder */
int ps;               /* Anzahl der PS */
char gas;             /* Art des Benzins S=Super, N=Normal, D=Diesel */
int abbruch;
};

/********************************************************************************
 Prototypen eingabe um den struct-array zu fuellen, ausgabe um ihn auszulesen
 ********************************************************************************/
void eingabe(struct wagen *);
void ausgabe(struct wagen *,struct wagen *);

int main()
{
short anzahl;

/**********************************************************************************************************
 der zeiger pkws der als adresse benutzt wird anstatt einem variablenname 
 der zeiger control, der immer auf den anfang des strukturarrays zeigt, dient zum zurücksetzten von *pkws
 **********************************************************************************************************/
struct wagen *pkws,*control;
printf("Wie viele Autos wollen sie speichern  ");
do{scanf("%d",&anzahl); } while(getchar()!='\n');

/***************************************************************
  reserviert speicher für jeden datensatz der eingegeben wird
  **************************************************************/
pkws=malloc(anzahl*sizeof(struct wagen));
if(!pkws)
{
printf("\nNicht genug freier Speicher verfuegbar");
return 0;
}

/******************************************************************
 gibt der variablen abbruch des letzten datensatzes den wert -1. 
 dieser stellt die abbruchbedingung für die scheifen da
 ******************************************************************/
control=pkws;
pkws+=anzahl;
pkws->abbruch=-1;
pkws=control;
printf("Bitte machen sie Eingaben fuer %d Autos",anzahl);
eingabe(pkws);
printf("\nSie haben folgende Daten angegeben");
ausgabe(pkws,control);
}

/*******************************************
 Die Eingabe der Auto-Daten in den Speicher
 *******************************************/
void eingabe(struct wagen *pkws)
{
short index=1;
printf("\nBitte machen sie ihre Eingaben");
printf("\nnach dem Syntax name,temp,anzahl zylinder,ps und benzing");
printf("\nzB Audi a3 350.0 4 300 S\n");
for(;pkws->abbruch!=-1;pkws++,index++)
{
printf("\nMachen sie ihre eingabe fuer das %d. Auto\n",index);
gets(pkws->name);
do{scanf(" %f %d %d %c",&pkws->speed,&pkws->zylinder,&pkws->ps,&pkws->gas); } while(getchar()!='\n');
}
}

/****************************************
 Ausgabe der eingetragenen Daten
 ****************************************/
void ausgabe(struct wagen *pointer,struct wagen *control)
{
for(pointer=control;pointer->abbruch!=-1;pointer++)
{

printf("\nDie Daten der Autos\n");
printf("Name %s | Tempo %f | Zylinder %d | PS %d | Benzin %c\n\n",pointer->name,pointer->speed,pointer->zylinder,pointer->ps,pointer->gas);
}
system("PAUSE");
}