# C/C++ Ganzes Programm, wer Lust & Zeit hat



## MPNuts (24. November 2004)

Ich musste im Rahmen meines Studiums ein Programm erstellen. Da ich aber noch im ersten Semester bin, und das Programmieren noch recht neu für mich ist. Habe ich mir gedacht, ich poste mal das Programm. Und wer Zeit und Lust hat, kann sich es ja mal durchlesen und seine Meinung darüber schreiben. 

Ich hoffe vorallem, dass mir auf diese Weise jemand sagt, was ich verbessern kann, was sehr unglücklich gelöst ist, vieleicht auch ein paar Anmerkungen zum Stil im Allgemeinen.

Ein paar Antworten über meine Kommentare würden mich besonders freuen, da ich nie weiss, was ich wie Kommentieren soll!

Versteht mich nicht falsch, ich will mir durch eure Hilfe kein besseres abschneiden ermöglichen, das Programm wird morgen abgegeben, die Dokumentation und die Strucktogramme sind bereits gedruckt, ergo, ich ändere nichts mehr daran.

Ich bedanke mich schonmal im voraus, da das sicherlich nicht gerade spassig ist!


```
/*In diesem Programm werden String bearbeitet. Es werden zwei Strings entgegen genommen, diese 
werden dann zu einem gemeinsamen String zusammengefügt. Danach können sie noch über verschiedene
Funktionen bearbeitet werden.
Dieses Programm wurde geschrieben von Schmidt Soeren, es wurde fertiggestellt am 23.11.04*/
#include <conio.h>
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
 
struct umlaut //Struct zur Darstellung der Umlaute
{
char o;
char a;
char u;
};
struct array //Struct zur Aufnahme der Arrays
{
char * p;
int index;
};
struct pointer
{ //Dieses Struct enthält 3 Pointer, die auf die struct arrays der Arrays zeigen
array* pqary1;
array* pqary2;
array* pzary;
};
struct umlaut uml; //Deklarieren von uml mit struct umlaut
	 //Hiermit werden alle Umlaute ausgegeben
```
 

```
//////////////////////////////////////////////////////////////////////////////////////////////
///////// main
//////////////////////////////////////////////////////////////////////////////////////////////
void main ()
{
int prend;	//Programm Abbruch, Größe des ZielArrays
char a;
struct array zary; //Deklarieren von zarray mit ary
struct array qary1; //Deklarieren von qarray mit qary
struct array qary2;
struct pointer pr; //Zur Annahme der Nutzerauswahl
uml.o='\x94'; //Beschreiben des uml Structs
uml.a='\x84';
uml.u='\x81';
pr.pqary1=&qary1; //Beschreiben des pr Pointer Structs
pr.pqary2=&qary2;
pr.pzary=&zary;
do	 //Programmschleife
{
system("cls"); //Bildschirm leeren
printf("\n\t\t\tMenue\n\n\t\tStart \t\t[s]\n\t\tVer%cndern \t[v]\n\t\tAbout \t\t[a]",uml.a);
printf("\n\t\tBeenden \t[b]");
a=getch(); //Annahme Benutzerwahl
system("cls"); //Bildschirm leeren
switch (a) //Auswertung der Benutzereingebe
{
case('s'):{ //Aufruf von f(verein)
verein(pr);
prend=1;
break;}
case('v'):{ //Aufruf von f(veraender)
veraender(zary);
prend=1;
break;}
case('b'):{ //Abbruchbedingung der Schleife
prend=-1;
printf("\n\n\t\t");
break;}
case('a'):{ //Aufruf der Programmbeschreibung
about();
prend=1;
break;}
default:{ //Wiederholung der Schleife
prend=1;}
}
} while (prend>0);
if ((pr.pzary->p)!=NULL)
{
//(pr.pzary->p)=NULL; //Zeiger wird auf NULL gesetzt
free(pr.pzary->p);
}
 
}
//////////////////////////////////////////////////////////////////////////////////////////////
///////// main
//////////////////////////////////////////////////////////////////////////////////////////////
```


```
//////////////////////////////////////////////////////////////////////////////////////////////
///////// verein
//////////////////////////////////////////////////////////////////////////////////////////////
/*In dieser Funktion werden werden alle Formationen an den Zählvariablen durchgeführt, desweitern
findet hier auch die Ausgaben der Arrays statt.Sie wird von f(main) aufgerufen. Selbst ruft sie 
f(eingabe), f(deref) und f(indize) auf. Als Parameter erhält sie den pointer struct.*/
void verein (struct pointer pr)
{
char a;	 //Auswahl on Indizes oder Dereferentiert
int i;	 //Zählvariablen
 
do
{
do
{
printf("\nBitte geben Sie die erste Zeichenfolge ein:\n\t");
*(pr.pqary1)=eingabe(); //Aufruf der eingabe Funktion, erstellen und beschreiben des Arrays
printf("\nBitte geben Sie die zweite Zeichenfolge ein:\n\t");
*(pr.pqary2)=eingabe(); //Aufruf der eingabe Funktion, erstellen und beschreiben des Arrays
(pr.pqary1->index)--;(pr.pqary2->index)--;
(pr.pzary->index)=(pr.pqary1->index)+(pr.pqary2->index); //Errechnen der Größe des Ziel-Arrays
printf("\n\nIst diese Eingabe korrekt?\nD%ccken Sie 'j' um die Eingabe zu best%ctigen\n",uml.u,uml.a);
a=getch();
system("cls");
}while (a!='j');
(pr.pqary1->index)--;
(pr.pqary2->index)--; //Formatieren der Zählwerte
printf("\n\t1. Dereferenziert\n\t2. Indizes");
a=getch();
system("cls");
 
if (a=='1') //Auswahl welche Sotierfunktion benutzt wird
{
deref(pr);
}else	//Aufruf der Sotierfunktion mit Dereferenzierung
{
indize(pr);
}	 //aufruf der Sotierfunktion mit Indizes
(pr.pqary1->index)++;(pr.pqary2->index)++;
printf("\n\t1. Zeichenkette\t: ");
for (i=0; i < (pr.pqary1->index); i++)//Ausgabe des ersten Arrays
{
printf("%c", (pr.pqary1->p)[i]);
}
printf("\n\t2. Zeichenkette\t: ");
for (i=0; i < (pr.pqary2->index); i++)//Ausgabe des zweiten Arrays
{
printf("%c", (pr.pqary2->p)[i]);
}
printf("\n\n\tZiel-Array\t: ");
for (i=0; i < (pr.pzary->index); i++)//Ausgabe des Zielarrays
{
printf("%c", (pr.pzary->p)[i]);
}
free(pr.pqary1->p); //Speicherplatz wir wieder freigegeben
free(pr.pqary2->p);
printf("\n\nSind Sie mit dem Ergebnis unzufrieden?\n\tDann dr%ccken Sie 'j', ",uml.u);
printf("jede andere Taste um fortzufahren.");
a=getch();	//Annahme der Wahl des Nutzers
system("cls"); //Bildschirm leeren
}while (a=='j'); //Auswertung der Benutzereingabe zum Abbruch der Schleife
}
//////////////////////////////////////////////////////////////////////////////////////////////
///////// verein
//////////////////////////////////////////////////////////////////////////////////////////////
```


```
//////////////////////////////////////////////////////////////////////////////////////////////
///////// veraender
//////////////////////////////////////////////////////////////////////////////////////////////
/*Diese Funktion enthält das Menü zum verändern der Zeichenketten. Sie wird von main gerufen,
selbst ruft sie f(tausch), f(gross) und f(klein). Als Parameter bekommt sie den zary struct.*/
void veraender (struct array ver)
{
char a;	 //Zur Annahme der Nutzerauswahlen und Abbruch für Schleife
 
do	 //Schleife in der diese Funktion läuft
{
system("cls"); //Bildschirm leeren
printf("In diesem Men%c k%cnnen Sie ihre vorher eingegebe Zeichenkette ver%cndern.",uml.u,uml.o,uml.a);
printf("\n\n\tSie k%cnnen W%chlen zwischen:\n\t\tGross-/Kleintausch \t[t]\n\t\t",uml.o,uml.a);
printf("Alles gross \t\t[g]\n\t\tAlles klein \t\t[k]\n\t\tKeine %cnderung \t\t[b]",uml.a);
a=getch();	//Annahme der Wahl des Nutzers
switch (a)
{
case('t'):{ //Aufruf von f(tausch)
tausch(ver);
a='b';
break;}
case('g'):{ //Aufruf von f(gross)
gross(ver);
a='b';
break;}
case('k'):{ //Aufruf von f(klein)
klein(ver);
a='b';
break;}
case('b'):{ //keine Änderung zurück zu main
a='b';
break;}
default:{ //Wiederholung der Schleife
a='w';}
}
} while (a!='b');
printf("\n\n\tVer%cnderte Zeichenkette\t: ",uml.a);
for (int i=0; i < ver.index; i++)//Ausgabe des Zielarrays
{
printf("%c", ver.p[i]);
}
getch();	//Warten auf Taste, dass der Nutzer das Ergebnis prüfen kann
system("cls"); //Bildschirm leeren
 
}
//////////////////////////////////////////////////////////////////////////////////////////////
///////// veraender
//////////////////////////////////////////////////////////////////////////////////////////////
```


```
//////////////////////////////////////////////////////////////////////////////////////////////
///////// about
//////////////////////////////////////////////////////////////////////////////////////////////
//Ausgabe der Programmbeschreibung, sowie der Autor, Versionsnummer und Datum
void about()
{
system("cls");
printf("Dieses Programm nimmt zwei Zeichenketten von beliebiger Gr%csse entgegen.",uml.o);
printf("\nDann werden diese zwei Zeichenketten zu einer Vereint. Es wird dabei folgender-\n");
printf("masen vorgegangen, das letzte Zeichen der ersten Zeichenkette wird das erste \nZeichen");
printf(" der neuen Zeichenkette. das letzte Zeichen der Zweiten das Zweite des \nNeuen usw.");
printf("\n\nDie neue Zeichenkette k%cnnen Sie dann noch weiter Veraendern, entweder Sie ",uml.o);
printf("\ntauschen Gross- mit Kleinbuchstaben, oder machen alle gross oder klein.");
printf("\n\n\t\tAutor:\tS%cren Schmidt\n\t\tVersion:\t1.0\n\t\tDatum:\t\t23 Nov 2004",uml.o);
printf("\n\nDr%ccken Sie eine beliebige Taste um fortzufahren",uml.u);
getch();
}
//////////////////////////////////////////////////////////////////////////////////////////////
///////// about
//////////////////////////////////////////////////////////////////////////////////////////////
```


----------



## MPNuts (24. November 2004)

```
//////////////////////////////////////////////////////////////////////////////////////////////
///////// indize
//////////////////////////////////////////////////////////////////////////////////////////////
/*In dieser Funktion werden die zwei Arras in das ZielArray geschrieben, es werden die Indizes
benutzt um die Arrays zu Positionieren. Als Parameter bekommt die Funktion das pointer
struct*/
void indize (struct pointer pr)
{
int x, y, z;	 //Größe des ZielArrays, Zählvariable
(pr.pzary->p)=getarray(pr.pzary->index);//Aufruf(getarray), Ziel-Array wird erstellt
x=(pr.pqary1->index); //Speichern der Werte in andere Variabelen, dass sie nicht
y=(pr.pqary2->index); //überschrieben werden
z=0;
for (int i=0; i < (pr.pzary->index); i++)
{
if (x>=0) //Bis Array zuende
{
(pr.pzary->p)[z]=(pr.pqary1->p)[x];
z++;x--;
}	 //Schreiben von Quell in Ziel-Array
 
if (y>=0) //Bis Array zuende
{
(pr.pzary->p)[z]=(pr.pqary2->p)[y];
z++;y--;
}	 //Schreiben von Quell in Ziel-Array
}
// return (pr.pzary->p);
}
//////////////////////////////////////////////////////////////////////////////////////////////
///////// indize
//////////////////////////////////////////////////////////////////////////////////////////////
 
//////////////////////////////////////////////////////////////////////////////////////////////
///////// deref
//////////////////////////////////////////////////////////////////////////////////////////////
/*In dieser Funktion werden die zwei Arras in das ZielArray geschrieben, es werden die Speicher-
adressen benutzt um die Arrays zu Positionieren. Als Parameter bekommt die Funktion das pointer
struct*/
void deref (struct pointer pr)
{
int x, y, z;	 //Größe des ZielArrays, Zählvariable
(pr.pzary->p)=getarray(pr.pzary->index);//Aufruf(getarray), Ziel-Array wird erstellt
x=(pr.pqary1->index); //Speichern der Werte in andere Variabelen, dass sie nicht
y=(pr.pqary2->index); //überschrieben werden
z=0;
for (int i=0; i < (pr.pzary->index); i++)
{
if (x>=0) //Bis Array zuende
{
*((pr.pzary->p)+z)=*((pr.pqary1->p)+x);
z++;x--;
}	 //Schreiben von Quell in Ziel-Array
if (y>=0) //Bis Array zuende
{
*((pr.pzary->p)+z)=*((pr.pqary2->p)+y);
z++;y--;
}	 //Schreiben von Quell in Ziel-Array
}
}
//////////////////////////////////////////////////////////////////////////////////////////////
///////// deref
//////////////////////////////////////////////////////////////////////////////////////////////
```
 

```
//////////////////////////////////////////////////////////////////////////////////////////////
///////// eingabe
//////////////////////////////////////////////////////////////////////////////////////////////
/*Über diese Funktion wird die Tastatureingabe der Arrays gesteuert. Sie gibt struct array mit
den Array+Größe zurück. Sie ruft selbst die Funktionen "getarray" und "getnewarray" auf*/
struct array eingabe () 
{		 
 
char a;		 //Zum Zwischenspeichern der chars
struct array inein;
(inein.index)=1;
do
{
a=getch();	 //Eingabe von der Tastatur
printf("%c",a);	 //Ausgabe der Eingegebenen Zeichen
if (a!=13)	 //Abfrage, ob die Entertaste betätigt wurde
{
if ((inein.index)==1)	 //Abfrage, ob bereits ein Array besteht
{
	inein.p = getarray(inein.index); //Aufruf von f(getarray)
}else
{
	inein.p = getnewarray(inein); //Aufruf von f(getnewarray)
}
(inein.p)[(inein.index)-1]=a;	 //Zuweisung der Tastatureingabe in das Array
(inein.index)++;
}
if ((inein.index)==1)
{
a='a';
}
} while (a!=13);	 //Abfrage, ob die Entertaste betätigt wurde
return inein;		//übergabe des Pointers an Programm
}
//////////////////////////////////////////////////////////////////////////////////////////////
///////// eingabe
//////////////////////////////////////////////////////////////////////////////////////////////
```
 

```
//////////////////////////////////////////////////////////////////////////////////////////////
///////// getarray
//////////////////////////////////////////////////////////////////////////////////////////////
/*In dieser Funktion werden die Arrays erstellt. Die "index" Variable dient zur Ermittlung der
Größe der Arrays. Es wird ein Pointer zurückgegeben*/
char * getarray (int index)
{
char * p;		//Pointer zur aufnahme des Arrays
p=(char*)malloc(index*sizeof(char)); //Das System wird nach Speicher gefragt
if (p==NULL)	 //Frage nach dem "NULL-Zeiger"
{
printf("Zu wenig Speicherplatz vorhanden");
}
return p;		//Rückgabe des Pointers mit dem Array
}
//////////////////////////////////////////////////////////////////////////////////////////////
///////// getarray
//////////////////////////////////////////////////////////////////////////////////////////////
 
//////////////////////////////////////////////////////////////////////////////////////////////
///////// getnewarray
//////////////////////////////////////////////////////////////////////////////////////////////
/*In deiser Funktion werden die Arrays bei Bedarf erweitert. Die Funktion erhält ein struct 
array mit den Daten des alten Arrays, und überschreibt diesen mit dem abgeänderten Array.*/
char * getnewarray (struct array get)
{
get.p = (char *) realloc(get.p,get.index*sizeof(char)); //Diese Funktion erweitert das Array
 
if (get.p==NULL)		 //Frage nach dem "NULL-Zeiger"
{
printf("Zu wenig Speicherplatz vorhanden");
}
return get.p;		 //Rückgabe des Pointers mit dem neuen Array
}
//////////////////////////////////////////////////////////////////////////////////////////////
///////// getnewarray
//////////////////////////////////////////////////////////////////////////////////////////////
```
 

```
//////////////////////////////////////////////////////////////////////////////////////////////
///////// tausch
//////////////////////////////////////////////////////////////////////////////////////////////
/*In dieser Funktion werden Kleinbuchstaben groß gemacht und umgekehrt. Sie gibt das vertauschte
Array wieder zurück. Übergeben wird ihr der zary struct.*/
void tausch(struct array ver)
{ 
int z=0;		//Zählvariable
for (z=0;z<ver.index;z++)	//Zählschleife, die das gesamte Array durchläuft
{ 
if((ver.p[z]>=65||ver.p[z]<=90)||(ver.p[z]>=97||ver.p[z]<=122))
{
if (islower(ver.p[z])) //Prüfen, ob die Variable klein ist
{
	ver.p[z]=toupper(ver.p[z]); //Tausch zu groß
}
else 
{
	ver.p[z]=tolower(ver.p[z]); //Tausch zu klein
}
}
}
} 
//////////////////////////////////////////////////////////////////////////////////////////////
///////// tausch
//////////////////////////////////////////////////////////////////////////////////////////////
 
//////////////////////////////////////////////////////////////////////////////////////////////
///////// gross
//////////////////////////////////////////////////////////////////////////////////////////////
/*In dieser Funktion werden alles Buchstaben groß gemacht, Parameter, zary struct*/
void gross(struct array ver)
{ 
for (int z=0;z<ver.index;z++) //Zählschleife, die das gesamte Array durchläuft
{ 
if (ver.p[z]>=97||ver.p[z]<=122)//Prüfen, ob die Variable klein ist
{
ver.p[z]=toupper(ver.p[z]); //Tausch zu groß
}
}
}
//////////////////////////////////////////////////////////////////////////////////////////////
///////// gross
//////////////////////////////////////////////////////////////////////////////////////////////
 
//////////////////////////////////////////////////////////////////////////////////////////////
///////// klein
//////////////////////////////////////////////////////////////////////////////////////////////
/*In dieser Funktion werden alles Buchstaben klein gemacht, Parameter, zary struct*/
void klein(struct array ver)
{ 
for (int z=0;z<ver.index;z++) //Zählschleife, die das gesamte Array durchläuft
{ 
if (ver.p[z]>=65||ver.p[z]<=90) //Prüfen, ob die Variable klein ist
{
ver.p[z]=tolower(ver.p[z]); //Tausch zu groß
}
}
}
//////////////////////////////////////////////////////////////////////////////////////////////
///////// klein
//////////////////////////////////////////////////////////////////////////////////////////////
```


----------



## LordDeath (24. November 2004)

Ist ein bisschen viel sich das alles anzuschauen !
Vielleicht kannst du ja mal posten was das Programm im gesamten machen soll. Das man mal schauen kann ob man das Problem vielleicht auch einfacher lösen kann.


```
if (ver.p[z]>=97||ver.p[z]<=122)//Prüfen, ob die Variable klein ist
{
ver.p[z]=toupper(ver.p[z]); //Tausch zu groß
}
```


----------



## LordDeath (24. November 2004)

Ist ein bisschen viel sich das alles anzuschauen !
Vielleicht kannst du ja mal posten was das Programm im gesamten machen soll. Das man mal schauen kann ob man das Problem vielleicht auch einfacher lösen kann.


```
if (ver.p[z]>=97||ver.p[z]<=122)//Prüfen, ob die Variable klein ist
{
   ver.p[z]=toupper(ver.p[z]); //Tausch zu groß
}
```

Hätte ich ohne die if Abfrage gemacht der Faulheit willen    !


```
ver.p[z]=toupper(ver.p[z]);
```


DarkGreetinx LordDeath


----------



## MPNuts (24. November 2004)

Hier die Aufgabenstellung, ich habe mich aber nicht strikt daran gehalten, desweiteren habe ich noch etwas mehr gemacht. Auf was ich besonders stolz bin, mein dynamisches Array, war auch nicht wirklich gefragt!


> Schreiben Sie ein C-Programm, dass folgende Stringbearbeitungen abbildet:
> Eine Funktion soll drei Strings entgegennehmen (Quelle1, Quelle 2, Ziel).
> Der Zielstring soll folgendermasse erzeugt werden:
> Das erste Zeichen des Zielstrings soll das letzte Zeichen von Quelle 1
> ...


Wenn niemand Lust hat, das Ganze sich anzutun, kann ich das sehr wohl verstehen, aber man könnte sich ja auch nur ein Stück vornehmen!


----------



## Thomas Kuse (24. November 2004)

Also wo kommen wir denn hier hin?
Einfach so Quellcode ohne Punkt und Komma, ohne richtige Frage...also sowas ist nicht in Ordnung!

Entweder Quellcode als Anhang mit einer richtigen Frage oder ganz lassen!

*closed*


----------

