IT-Academy Logo
Sign Up Login Help
Home - Programmieren - C++ - Arrays 1 (zusammengesetzte Datentypen, Felder)



Arrays 1 (zusammengesetzte Datentypen, Felder)

Wie schon aus der Überschrift hervorgeht, gibt es in C++ Datentypen, die sich aus den Grund-Datentypen zusammensetzen. Dies ist Gegenstand dieses Artikels.


Autor: Peter Schmitz (dav133)
Datum: 01-02-2006, 23:58:13
Referenzen: keine
Schwierigkeit: Fortgeschrittene
Ansichten: 9206x
Rating: 7 (1x bewertet)

Hinweis:

Für den hier dargestellte Inhalt ist nicht der Betreiber der Plattform, sondern der jeweilige Autor verantwortlich.
Falls Sie Missbrauch vermuten, bitten wir Sie, uns unter missbrauch@it-academy.cc zu kontaktieren.

[Druckansicht] [Als E-Mail senden] [Kommentar verfassen]



Arrays 1 (Felder und Zeichenketten)
Wie schon aus der Überschrift hervorgeht, gibt es in C++ Datentypen, die sich aus den Grund-Datentypen zusammensetzen. Dies ist Gegenstand dieses Artikels.
Von besonderer Bedeutung war bisher die notwendige Handhabung von Zeichenketten; was in den neuerenCompilern durch den nun standardisierten Datentyp string vereinfacht wird.
Ein Feld, Array genannt, dient dazu, eine Anzahl von Werten des gleichen Typs zu Speichern. Es handelt sich also um eine Art von Tabelle, in der z.B. Geburtsdaten oder die monatlichen Firmenumsätze für ein Jahr gewerden. Die Definition erfolgt folgendermaßen:


Datentyp Feldname [Anzahl_der_Elemente] ;

Beispiel:
const unsigned Monate = 12;	// Anzahl_der_Elemente muss eine Konstante sein !
short MonatsUmsatz[Monate] ;	// Datentyp = short ; Feldname = MonatsUmsatz ; 
				// Feldgröße = 12 Elemente, da Monate = 12



es wäre auch möglich - aber kein guter Programmierstiel - mit dem Einzeiler:short MonatsUmsatz[12] ;
Es wird in diesem Beispiel ein short-Array mit 12 Elementen reserviert. Dies bedeutet im Speicher 12 zusammenängende (also hintereinanderliegende) Speicherzellen vom Typ short (= 12 * 2 = 24 Bytes).

Es gibt kein spezielles Schlüsselwort für Felder (wie z.B. ARRAY in Pascal), sondern die Größe wird in eckigen Klammern hinter den Variablennamen geschrieben. Der Datentyp (Element-Typ) wird , wie auch sonst üblich , vor den Variablennamen gesetzt.
Es wird auch keine Felduntergrenze angegeben.


Die Feldelemente sind stets von 0 bis (Anzahl_der Elemente - 1) durchnumerieret !

in obigem Beispiel also von 0 bis 11

Der Zugriff auf Feldelemente wird durch den mit hoher Priorität versehenen [ ] Operator, Indexoperator genannt, ermöglicht. Ein Beispiel hierzu:

const unsigned Anzahl = 3 ;	// Konstante für 3 Feld-Elemente
short Tabelle[Anzahl] ;		// short-Array namens Tabelle mit 3 Elementen

.....				// innerhalb eines Programms
Tabelle[0] = 125;			// 1. Element = Tabelle[0] erhält den Inhalt 125
Tabelle[1] = 1000;		// 2. Element = Tabelle[1] erhält den Inhalt 1000
Tabelle[2] = 325;			// 3. Element = Tabelle[2] erhält den Inhalt 325 ; 
				// 3. Element = LETZTES Element


Als überaus wichtige Regel müssen wir uns allerdings merken:

C++ nimmt keinerlei Prüfungen auf Über- oder Unterschreitungen des Indexbereichs vor !

Zugriffe auf nicht existierende Elemente, im letzen Beispiel könnte dies u.a. Tabelle[1000] = 512 lauten, erzeugen keine Fehlermeldung und können, durch Überschreiben einer ev. lebensnotwendigen Speicherzelle, bis zum Systemabsturz führen.


Ein Programmbeispiel soll das Ganze noch einmal verdeutlichen:


#include 		// für Ein-/Ausgabe erforderlich

int main()
{
	const unsigned char anzahl = 3;		// Konstante für 3 Feldelemente
	short  wert[anzahl];			// Definition eines short-Arrays mit 3 Elementen

	// Werte eintragen		(geht natürlich auch anders, sogar einfacher; dazu später)
	// Es können auch Werte unbelegt bleiben, dann stehen 'zufällige' Inhalte in den Elementen
	// Die Reihenfolge spielt keine Rolle.
	wert[2] = 0xFF ;		// 3. Element = wert[2] erhält den Inhalt 255 (dezimal)
	wert[0] = 125 ;		// 1. Element = wert[0] erhält den Inhalt 125
	wert[1] = 1000 ;		// 2. Element = wert[0] erhält den Inhalt 1000
	
	// Ausgabe
	cout	<<  endl  <<  "Das Array 'wert' mit 3 Elementen vom Typ short:\n\n";
	cout	<<  "Der Inhalt von wert[0] lautet : "  <<  wert[0]  <<  endl ;
	cout	<<  "Der Inhalt von wert[1] lautet : "  <<  wert[1]  <<  endl ;
	cout	<<  "Der Inhalt von wert[2] lautet : "  <<  wert[2]  <<  endl ;
	cout	<<  "Die SUMME der drei Werte beträgt : "  <<  (wert[0] + wert[1] + wert[2])  
		<<  endl;
	cout	<<  endl  <<  "Jetzt der Zugriff auf den NICHT existenten Elementeintrag Nr 4\n";
	cout	<<  "Der zufällige Zahlenwert lautet : "  <<  wert[3] ;	// ungültiger Index  !
	cout	<<  endl  <<  endl  <<  "Programm-Ende" ;

	return  0;
}


Das Ergebnis am Bildschirm:

Das Array 'wert' mit 3 Elementen vom Typ short:

Der Inhalt von wert[0] lautet :  125
Der Inhalt von wert[1] lautet :  1000
Der Inhalt von wert[2] lautet :  255
Die SUMME der drei Werte beträgt :  1380

Jetzt der Zugriff auf den NICHT existenten Elementeintrag Nr 4
Der zufällige Zahlenwert lautet :  995

Programm-Ende


Der zufällige Zahlenwert kann bei Ihnen selbstverständlich anders lauten.

Die besprochene Array-Art nennt man eindimensionale Felder.
Demnach muss es auch mehrdimensionale Felder geben.

Mehrdimensionale Felder
Sie können auch zwei, drei oder noch mehr Dimensionen für Felder benutzen. Die am häufigsten auftretende Form dürfte die 2-dimensionale Tabelle sein; über drei Dimensionen hinaus werden allerdings Probleme mit der Vorstellungsfähigkeit auftreten.
Die Deklaration mehrdimensionaler Felder ist relativ einfach:

Jede weitere Dimension wird in eckigen Klammern hinter der vorhergehenden Dimension angefügt.
Datentyp Feldname [Elemente_Dimension1] [Elemente_Dimension2] [..............] ;

Das nachstehende Beispiel stellt eine zweidimensionale Tabelle dar (Matrix), welche aus 2 Zeilen (Dimension1) und 3 Spalten (Dimension2) bestehen soll:

#include 		// für Ein-/Ausgabe erforderlich

int main()
{
	const int dim1= 2, dim2 = 3;	// Konstante für 2 Feldelemente + 3 Feldelemente
	short  matrix[dim1] [dim2] ;	// Definition einer short-Matrix (2 Zeilen+3 Spalten)

	// Werte eintragen		(geht natürlich auch anders, sogar einfacher; dazu später)
	matrix[0] [0] = 11 ;	// 1. Zeile, 1. Spalte  erhält den Inhalt 11
	matrix[0] [1] = 12 ;	// 1. Zeile, 2. Spalte  erhält den Inhalt 12
	matrix[0] [2] = 13 ;	// 1. Zeile, 3. Spalte  erhält den Inhalt 13
	matrix[1] [0] = 21 ;	// 2. Zeile, 1. Spalte  erhält den Inhalt 21
	matrix[1] [1] = 22 ;	// 2. Zeile, 2. Spalte  erhält den Inhalt 22
	matrix[1] [2] = 23 ;	// 2. Zeile, 3. Spalte  erhält den Inhalt 23
	
	// Ausgabe
	cout	<<  endl  <<  "Die Matrix (2-dimensionales Array) mit 2 Zeilen und 3 Spalten :\n\n";
	cout	<<  "Der Inhalt der 1.Zeile lautet : "  <<  matrix[0] [0] ;
	cout	<<  "   "  <<  matrix[0] [1] ;
	cout	<<  "   "  <<  matrix[0] [2]  <<  endl ;
	cout	<<  "Der Inhalt der 2.Zeile lautet : "  <<  matrix[1] [0] ;
	cout	<<  "   "  <<  matrix[1] [1] ;
	cout	<<  "   "  <<  matrix[1] [2]  <<  endl ;
	cout	<<  endl  <<  "Programm-Ende" ;

	return  0;
}

Das Ergebnis am Bildschirm:

Die Matrix (2-dimensionales Array) mit 2 Zeilen und 3 Spalten :

Der Inhalt der 1.Zeile lautet :   11   12   13
Der Inhalt der 2.Zeile lautet :   21   22   23


Programm-Ende

Im Speicher liegen alle Elemente der 1. Dimension (Zeile), dahinter alle Elemente der 2.Diemension, ..........

In C und C++ darf der Zugriff auf ein Element eines mehrdimensionalen Arrays nicht, wie z.T. in anderen Programmierüblich, nicht mit einem Komma abgekürzt werden.
Also NICHT array[1,2] statt array[1][2] schreiben !
Der Compiler meldet die falsche Schreibweise nicht unbedingt !
Es sei noch erwähnt, dass in diesem Fall array[1,2] als array[3] interpretiert wird.

Arrays initialisieren

Es wurde schon in vorhergehenden Beispielen erwähnt, dass es einfachere Möglichkeiten gibt, Felder mit Werten zu belegen. Insbesondere bei großen Feldern, die ev. auch noch mehrere Dimensionen haben, kann es recht mühwerden, alle Feldelemente mit Werten zu belegen.
Und, dies gilt generell für alle Speicherstellen, durch alleinige Definition ohne Initialisierung stehen reine Zu(Müll) in den Speicherstellen !

Wenn wir uns das letzte Beispiel ansehen, können wir die Wertebelegung gleich bei der Definition miterledigen. Und zwar folgendermaßen:

const int dim1= 2, dim2 = 3;		// Konstante für 2 Feldelemente + 3 Feldelemente

// Es folgt die Definition mit gleichzeitiger Initialisierung
short  matrix[dim1] [dim2] = { 
				{11, 12, 13} , 
				{21, 22, 23} 
			   } ;

Ein vorher aufgestellter Satz soll hier noch mal in Erinnerung gebracht werden:

Im Speicher liegen alle Elemente der 1. Dimension (Zeile), dahinter alle Elemente der
2.Diemension, ..........

Die Initialisierungsliste enthält also die Werte, jeweils durch Kommata getrennt.

Selbstverständlich können Sie die Liste auch so schreiben:

short  matrix[dim1] [dim2] = { {11, 12, 13} , {21, 22, 23} } ;

Was ebenfalls möglich ist; aber tun Sie's trotzdem nicht:

short  matrix[dim1] [dim2] = { 11, 12, 13, 21, 22, 23 } ;


Jetzt möchte ich Ihnen eine Möglichkeit der Arbeitsersparnis (für den Programmierer; nicht den Compiler) vorstellen, bei der wir später auch noch feststellen werden, wie wichtig geschweifte Klammern sein können.

Die ERSTE Dimensionierung kann entfallen, wenn für den Compiler aus den folgenden Angaben die Größe ersichtlich ist. Sowohl bei eindimensionalen, als auch bei mehrdimensionalen Feldern gilt dies immer NUR für die erste Dimension.

Als 1.Beispiel soll ein eindimensionales Feld dienen:

int  i_werte[ ] = { 18, 125, 7, 11, 312, 6 };


Der Compiler kann sich selbst den Wert in den eckigen Klammern ermitteln [6] , warum soll ich diesen Wert also hineinschreiben (vielleicht verschreibe ich mich auch noch).

Als 2.Beispiel kommt die bekannte Matrix zurück:

short  matrix[ ] [3] = { 11, 12, 13, 21, 22, 23 } ;


Auch hier kann sich der Compiler den Wert für die ERSTE eckige Klammer errechnen [2], allerdings nur dann, wenn ALLE Werte in der geschweiften Klammer stehen.

Als 3. Beispiel verändern wir die Initialisierungsliste etwas:

short  matrix[ ] [3] = { {11} , {21, 22, 23} } ;


Was steht denn jetzt im ArrayÞ 11, 0, 0, 21, 22, 23
Für die erste Zeile steht nur die Zahl 11 in der geschweiften Klammer, so dass die allgemeine Regel gilt:

Nicht aufgeführte Elemente der Liste werden mit 0 initialisiert

Hätten wir jetzt keine geschweiften Klammern für die Dimensionen gesetzt, also = ;
dann würde im Array Þ 11, 21, 22, 23, 0, 0 stehen.

Zeichenketten

Wenn uns der Datentyp string nicht zur Verfügung steht, weil wir nicht die allerneuste Compilerversion besitzen, müssen wir uns so behelfen, wie es schon immer war - mit Zeichenketten.

Zeichenketten, auch als Strings bezeichnet, bestehen auch aus einem Feld und zwar vom Typ char.
Die Definition zur Aufnahme eines Textes könnte folgendermaßen aussehen:

char text[11] ;		// ein char-Array mit 11 Elementen; für 10
Zeichen


Dies bedeutet, dass Platz für 11 Zeichen reserviert wird. Aber nicht für einen Text mit 11 Zeichen, sondern für einen Text mit 10 Zeichen !
Der Grund liegt darin, dass das Ende einer Zeichenkette mit einer binären Null markiert wird. Diese binäre Null hat den ASCII-Code 0 und soll nichts mit dem Ziffernzeichen '0' verwechselt werden. Þ '
Sie erwirkt das Ende des zugewiesenen Textes.

Wenn nun z.B. folgende Zuweisungen erfolgen:

text[0] = 'E';
text[1] = 'i';
text[2] = 'n';
text[3] = ' ';
text[4] = 'T';
text[5] = 'e';
text[6] = 'x';
text[7] = 't';
text[8] = '\0';		// dann sind noch 3 char-Elemente frei, die nicht benutzt werden; 
			// und mit
cout  <<  text ;		// wird der Text ausgegeben (bis zur binären 0).

dann erscheint auf dem Bildschirm der Text, von text[0] beginnend, bis zum Auftreffen eines Text-Ende-Zeichens, welches selbst nicht mehr mit ausgegeben wird :

Ein Text


Wie löscht man nun diesen ganzen Text ?
Ganz einfach, indem man ins erste Feld-Element das Stringende schreibt !

text[0] = '\0' ;


Das Ende eines Textes mit der binären Null zu kennzeichnen hat etwas für sich; man kann theoretisch beliebig lange Strings erzeugen. Andere Sprachen kennen diese Ende-Markierung nicht, haben dafür aber die Länge am Anfang des Strings in ein oder zwei speziellen Stellen vermerkt; was zwar die Länge eines Strings sehr schnell ermitteln lässt, sich sonst aber wesentlich unflexibler darstellt.

Wenn man immer so mühselig Zeichenketten aus Einzelbuchstaben erzeugen müsste wie in unserem Beispiel, dann würde wohl kaum noch Text produziert. Zum Glück haben schon die C-Entwickler daran gedacht zahlreiche Standard-Funktionen zur Stringbearbeitung fertig zur Verfügung zu stellen. Diese Funktionen befinden sich in der Bibliothek <string.h>, die wir dann bei Bedarf zusätzlich einbinden müssen.

#include 			// für die Verwendung von Stringfunktionen
erforderlich

Die Funktionen sind im Handbuch eines C++-Systems (und in der Online-Hilfe) beschrieben. Hier sollen exemeinige wenige als Anwendung in einem Beispiel gezeigt werden.
Stringlänge ermitteln mit strlen() .
Texte kopieren mit strcpy() .
Texte anhängen mit strcat() .


#include 		// für Ein-/Ausgabe erforderlich
#include 		// für Stringfunktionen (strlen, strcpy, strcat, ....)

int main()
{
	const int laenge = 20;			// Konstante für char-Feld
	// Mit nachstehender Variablen text werden für 20 Zeichen Speicher reserviert
	// Mit dieser Definition liegt zunächst ein 'zufälliger' Inhalt vor !
	// Im Gegensatz zu text2, der gleich (mit konkretem Inhalt) initialisiert wird.
	char  	text[laenge] ,		// 19 Zeichen + '\0' möglich
		text2[ ] = "-Welt";	// 5 Zeichen + '\0' gibt text2[6]; und keine 'echte'
Konstante

	// Ausgabe
	cout	<<  endl  <<  "Stringverarbeitung mit Feldern :\n\n";
	strcpy(text, "Hallo C++") ;	// Kopiert den in Anführungsstrichen stehenden Text in text
					// strcpy fügt (in text) automatisch '\0' an !
	cout	<<  "Der Textinhalt von Feld text lautet : "   <<  text   <<  endl;
	cout	<<  "Die Länge des Textes ist : "
		<<  strlen(text)		// strlen ermittelt die Länge ohne '\0' mitzuzählen
		<<  endl ;
	cout	<<  "Durch Anhängen von text2 \'"  << text2
		<<  "\' an text \'"  <<  text
		<<  "\' ergibt sich  "  << endl ;
	strcat(text, text2);		// strcat hängt die Zeichenkette text2 an die Kette text an
					// dabei wird die in text vorhandene binäre Null
					//  überschrieben und am Ende an text eine '\0' angehängt
	cout	<<  "der neue Textinhalt von text : "
		<<  text  <<  endl ;
	cout	<<  "Mit einer neuen Textlänge von : "  <<  strlen(text) <<  endl ;
	cout	<<  endl  <<  "Programm-Ende" ;

	return  0;
}

Das Ergebnis am Bildschirm:


Stringverarbeitung mit Feldern :

Der Textinhalt von Feld text lautet : Hallo C++
Die Länge des Textes ist :   9
Durch Anhängen von text2 '-Welt' an text 'Hallo C++' ergibt sich
der neue Textinhalt von text : Hallo C++-Welt
Mit einer neuen Textlänge von : 14

Programm-Ende


Achten Sie bei der Verwendung (aller) Arrays darauf, dass das aufnehmende Feld groß genug ist !

Zeichenketten initialisieren
Wie man Zeichenketten bereits bei der Definition einen Wert zuweist - also initialisiert - wurde im letzten Beispiel schon demonstriert.

char begriff[ ] = "Stuhl";


Diese Definition veranlasst den Compiler dem char-Feld begriff 6 Zeichen (Byte) zu reservieren; sowie die Zeichenkette "Stuhl" in die Feldelemente 0 bis 4 einzutragen und im Feldelement 5 mit der binären Null abzußen.

Eine weitere Möglichkeit mit 2-dimensionalen char-Feldern soll noch gezeigt werden:

char engl_wort [14] [9] = {
				"zero"  , "one"   , "two" , "three", "four"    , "five"     ,
"six", 
				"seven", "eight" , "nine", "ten"    , "eleven", "twelve",
"thirteen" 
			};

Was haben wir denn mit dieser Definition einschließlich Initialisierung gemacht ?
Ein zweidimensionales Feld, welches 14 Zeilen mit jeweils 9 Spalten aufweist. Diese Zellen wurden dann Zeile für Zeile mit den vorgegebenen Inhalten belegt; wobei jede Zeile (=Zeichenkette) mit der binären Null abschließt.

Das ganze sieht dann so aus:


z

e

r

o

\0

 

 

 

 

O

n

e

\0

 

 

 

 

 

T

w

o

\0

 

 

 

 

 

T

h

r

e

e

\0

 

 

 

F

o

u

r

\0

 

 

 

 

F

i

v

e

\0

 

 

 

 

S

i

x

\0

 

 

 

 

 

S

e

v

e

n

\0

 

 

 

e

i

g

h

t

\0

 

 

 

n

i

n

e

\0

 

 

 

 

t

e

n

\0

 

 

 

 

 

e

l

e

v

e

n

\0

 

 

t

w

e

l

v

e

\0

 

 

t

h

i

r

t

e

e

n

\0


Die Breite ( 9 Elemente ) muss für den längsten String ausgelegt werden ! Die 1. Dimension (Länge) richtet sich nach der Anzahl der zu verwendenden Strings.
Wenn Sie übrigens einen einzelnen Buchstaben ansprechen wollen, so geht dies ähnlich dem bei Zahlen, durch

engl_wort[Zeile] [Spalte] = 'Wert';

also z.B. mit

engl_wort[6][1] = 'a';


wird aus dem String "six" der String "sax".

Stringeingabe


const int max = 80 ;	// Konstante für Textfeld
char text[max] ;		// hier können maximal 79 Zeichen + \0 untergebracht werden.

cin  >>  text ;		// liest Ihre Eingabe bis zum 1. Whitespace ein

Zur Erinnerung, unter Whitespace fallen Leerzeichen (' '), Tabulatorzeichen (neue Zeile (
Dies bedeutet, dass z.B. beim Eingeben eines Namens die Eingabe nach dem ersten Namensteil beendet ist, weil dann ein Leerzeichen kommt.

Wenn Sie hierfür aber

cin.getline(text, max) ;


verwenden, können Sie bis zu max-1 (hier = 79) Zeichen eingeben, welche in der Variablen text abgelegt , und nach RETURN mit dem Stringendezeichen (abgeschlossen werden.

Je größer Sie die Konstante wählen, um so größer kann der von Ihnen einlesbare Text ausfallen. Das Textfeld der Variablen muss aber mindestens die Größe der Konstante besitzen !

Im nächsten Artikel folgen Strukturen und zusammengesetzte Datentypen.

Zusammenfassung
  • Ein Feld, Array genannt, dient dazu, eine Anzahl von Werten des gleichen Typs zu Speichern. Dabei erfolgt die Definition mit: DatenTyp FeldName[Anzahl]
  • Die Feldelemente sind stets von 0 bis (Anzahl-1) durchnumerieret.
  • Es erfolgt keinerlei Überprüfung des Indexbereiches (Über-/Unterschreitung).
  • Felder können ihre Werte für einzelne Elemente im Programm -per Zuweisung- erhalten, aber auch durch Einschluß in geschweifte Klammern bei der Definition initialisiert werden (dann werden nicht aufgeführte Elemente der Liste mit 0 initialisiert).
  • Mehrdimensionale Felder werden definiert, indem für jede Dimension eine eckige Klammer mit der Elementöße dieser Dimension angegeben wird: DatenTyp FeldName[Anzahl_Dim1] [Anzahl_Dim2] ....
  • Die ERSTE Dimensionierung kann entfallen (ein- und mehrdimensional), wenn für den Compiler aus den folgenden Angaben die Feldgröße ersichtlich ist.
  • Zeichenketten (Strings) bestehen aus char-Feldern und werden mit einer binären Null (als Endekennung abgeschlossen
  • In der Bibliothek <string.h> gibt es zahlreiche Hilfsfunktionen zur Handhabung von Strings; wie z.B. strcpy(), strlen(), strcat(), strcmp(), .......
  • Zeichenketten können schon bei der Definition initialisiert werden. Der Einschluß des Textes in Hochkommata beinhaltet das automatische Anfügen der String-Endekennung (im Feld.
  • Auch mehrdimensionale Zeichenketten sind möglich und können ebenfalls bei ihrer Definition initialisiert werden.
  • Bei der String-Eingabe mit cin ist zu beachten, dass Whitespaces die Eingabe beenden. Bei Bedarf muss dann die Member-Funktion cin.getline() verwendet werden.






    Aufgabe
    Schreiben Sie ein Programm, welches zwei Zeichenketten über die Tastatur einliest und sie zusammengefügt in einer dritten Variablen speichert. Geben Sie alle drei Zeichenketten am Bildschirm aus.

    Lösung

    //---------------------------------------------------------------------------
    
    #pragma hdrstop
    #include 
    #include 
    
    //---------------------------------------------------------------------------
    
    #pragma argsused
    int main(int argc, char* argv[])
    {
    
    char Eingabe1[10];
    char Eingabe2[10];
    char Ausgabe[20];
    
    cout << "Geben Sie bitte eine Zeichenkette ein.\n";
    cin >> Eingabe1;
    
    cout << "\nGeben Sie bitte eine weitere Zeichenkette ein.\n";
    cin >> Eingabe2;
    
    cout << "\n\nDie beiden Zeichenketten werden nun verknuepft.\n";
    
    strcat(Eingabe1,Eingabe2);
    //Beide Eingabe aneinander Anhängen
    strcpy(Ausgabe,Eingabe2);
    //...und die erste Variable (die ja nun beide Zeichenketten enthält) in die geforderte dritte
    Variable kopieren.
    
    cout << Ausgabe;
    
    cout << "\n\nProgramm-Ende";
    getch();
    
    return 0;
    }
    //---------------------------------------------------------------------------



    dav133
    Professonial
    Beitrag vom:
    12-02-2006, 20:18:15

    hmm

    Die Gliederung war in meinem Word-Dokument auf jeden Fall besser, als sie hier zu sehen ist. Finde ich etwas unfähr, Punktabzug zu geben, obwohl die .DOC => .HTML Kovertierung nicht meine "Schuld" war.

    lg

    -----------------------------------------------------


    paedubucher
    Professonial
    Beitrag vom:
    12-02-2006, 20:07:24

    Recht schön

    Insgesamt ein ordentlicher Artikel (werde mir dann den zweiten Teil zu einem späteren Zeitpunkt zu Gemüte führen), jedoch hättest du ihn etwas schöner strukturieren können.

    Für den Code hättest du vielleicht eine andere Schriftart verwenden sollen (z.B. Courir New), so würden einem die Codestücke etwas besser ins Auge stechen, als wenn es gleich formatiert ist wie der Text.

    NACHTRAG: Sorry, der Code ist ja in einer anderen Schriftart, ich war von einem anderen Artikel wohl etwas abgelenkt ;-)

    -----------------------------------------------------


    [back to top]



  • Userdaten
    User nicht eingeloggt

    Gesamtranking
    Werbung
    Datenbankstand
    Autoren:04508
    Artikel:00815
    Glossar:04116
    News:13565
    Userbeiträge:16552
    Queueeinträge:06246
    News Umfrage
    Ihre Anforderungen an ein Online-Zeiterfassungs-Produkt?
    Mobile Nutzung möglich (Ipone, Android)
    Externe API Schnittstelle/Plugins dritter
    Zeiterfassung meiner Mitarbeiter
    Exportieren in CSV/XLS
    Siehe Kommentar



    [Results] | [Archiv] Votes: 1154
    Comments: 0