ich bin neu in dem Forum und bei c++ auch, ich hoffe ihr könnt mir helfen. Irgendwie weiss ich nicht mehr wie es weiter geht.
so hier ist mein code :

#include <iostream>
#include <cstring>
using namespace std;

class teilnehmer
{
private :
	char vorname [30] ;
	char nachname [30];
	int matrikelnummer;
public:
	teilnehmer ();
	teilnehmer (char v[30], int m, char n[30]);
	void print ();
};

teilnehmer :: teilnehmer ()
{
vorname [30] = '0';
nachname [30] = '-';
int matrikelnummer = 0;
}

teilnehmer :: teilnehmer(char v [30], int m, char n[30])
{
vorname [30] = v [30];
matrikelnummer = m;
nachname [30] = n [30];

        cout << "Der Vorname ist : " <<  v << " und die Matrikelnummer ist : " << m << endl;

}

void teilnehmer :: print ()
{

	if (nachname [30]  != '-')
	{
		cout << "Der Nachname ist : " << nachname [30] << endl;
	}
}

int main ()
{
	teilnehmer t1 ("Kevin", 123456, "Mueller");
	t1.print();
	teilnehmer t2 ("Franz", 112233, "Schuhmacher");
	t2.print();
	teilnehmer t3 ("Lisa", 102356  , "Fritz");
	t3.print();
	teilnehmer t4 ("Manfred", 258963, "Schmitt");
	t4.print();

	return 0;
}

ich hoffe das war nicht zu lang.
ein Teil der Aufgabe verstehe ich nicht und genau das ist mein Problem :

Definieren Sie die Tabelle der 16 Teilnehmer als ein Array aus Objekten der Klasse
„Teilnehmer“. Befüllen Sie die ersten 4 Objekte mit einer Initialisierungsliste. Die
restlichen 12 Objekte wird der Standardkonstruktor befüllen.
Bauen Sie für das Ausgeben eine geeignete Schleife.

Für eure hilfe bedanke ich mich im Voraus.

/edit pumuckl: cpp-Tags, quote-Tags. Nächstemal bitte selber machen!

vorname [30] = v [30];

Dir fehlen noch ordentlich Grundlagen, oder?
vorname[30] gibt dir einen ungültigen (!) Wert im Array! Dein Array hat Länge 30, fängt bei 0 an, damit liegt der höchste Index bei 30-1=29.
Außerdem willst du doch dem Vorname einen Wert zuweisen und nicht nur einen einzigen Buchstaben setzen.

Was aber jetzt dein Lehrer mit "Initialisierungsliste" genau meint, ist mir nicht klar. Eigentlich hat der Begriff eine spezielle Bedeutung:

class Person {
    const char* _name;
    const char* _vorname;
public:
    Person( const char* name, const char* vorname )
     : _name(name), _vorname(vorname) // DAS ist eine Initialisierungsliste!
    {}
};

Ich denke du solltest dein Script nochmal durcharbeiten und schauen ob da nicht alles benötigte drinnensteht.

teilnehmer :: teilnehmer ()
{
vorname [29] = '0';
nachname [29] = '-';
int matrikelnummer = 0;
}

Hier musst du auch folgendes bedenken:

- 29 ist der letzte, gültige Index, wie schon erwähnt wurde
- vorname besitzt nun zwar eine terminierende Null, der Müll, der davor im Speicher liegt, ist aber trotzdem unschön. Du willst doch eine leere Variable vorname haben. Dementsprechend sollte das erste Element genullt werden, nicht das letzte. Oder man setzt die ganzen 30 Elemente auf Null (z.B. memset).
- Was erhoffst du dir von dem '-' in nachname? Spätestens dort gehört die Nullterminierung hin.

Schau dir am besten mal per Debugger an, worauf die Zeiger zeigen, nachdem du diesen Konstruktor aufgerufen hast (nämlich der Datenmüll, der zufällig noch an diesen Stellen im Speicher liegt).

EDIT:
Übersehen: Es muss natürlich 0 oder '\0' sein, nicht '0'...

#include <iostream>
#include <cstring>
using namespace std;

class teilnehmer
{
private :
char vorname [30] ;
char nachname [30];
int matrikelnummer;
public:
teilnehmer ();
teilnehmer (char v[30], int m, char n[30]);
void print ();
};

Die bessere Alternative zu char[30] ist natürlich std::string. Aber man sollte trotzdem wissen, wie Felder funktionieren. Beispielsweise findet eine Typtransformation bei Funktionsparametern statt: Ein Parametertyp T[] oder T[N], wobei T irgendein anderer Typ (einschließlich Arrays) und N eine integrale Konstante ist, wird tatsächlich zu T* umgeformt. Arrays kann man nämlich nicht, wie "normale" Variablen benutzen. Man kann sie nicht einfach so kopieren oder zuweisen wie int s, double s, etc...

Dann gibt es noch so etwas, was sich "array to pointer decay" im Englischen schimpft. Das ist eine automatische Konvertierung, die einem ein Zeiger auf das erste Element geben kann. Beispiel:

int array[3];
int* z = array;  // ist das gleiche wie  = &array[0];

<zaunpfahlwink>
Das kann man in guten Lehrbüchern nachlesen. Sich ein gutes Lehrbuch anzuschaffen, ist auch keine schlechte Idee. Gerade bei C++, welches auf C aufbaut, gibt es viel Wissenswertes, was durch reines Experimentieren kaum erlernt werden kann. Im Gegenteil, die Gefahr beim reinen Experimentieren ist die, dass man falsche Schlüsse aus dem Compiler- / Programmverhalten ziehen kann. Dass Anfänger so viele Probleme mit Arrays und Zeigern haben, ist meiner Ansicht nach Beleg genug dafür.
</zaunpfahlwink>

teilnehmer :: teilnehmer ()
{
vorname [30] = '0';
nachname [30] = '-';
int matrikelnummer = 0;
}

Da Du Dir die Länge der Zeichenketten nicht extra merkst, solltest Du sie wenigstens null-terminieren. Das Zeichen dafür ist '\0' und nicht '0'.

teilnehmer :: teilnehmer(char v [30], int m, char n[30])
{
vorname [30] = v [30];
matrikelnummer = m;
nachname [30] = n [30];
cout << "Der Vorname ist : " << v << " und die Matrikelnummer ist : " << m << endl;
}

Nein, nein, nein. Bitte nochmal das Thema Arrays und Zeiger im Lehrbuch nachschlagen. v und n sind hier Zeiger (wegen der Typtransformation bei Funktionsparametern). vorname und nachnahme sind zwar Arrays, aber die [30]-Syntax ist sowieso falsch. x[y] ist -- sofern der [] Operator bei x nicht überladen worden ist -- äquivalent zu *(x+y) . Das heißt, Du greifst auf das 31ste Element des vorname-Arrays zu, welches es gar nicht gibt. Peng!

void teilnehmer :: print ()
{
if (nachname [30] != '-')
{
cout << "Der Nachname ist : " << nachname [30] << endl;
}
}

Trifft hier genauso zu. Das [30] hat hier nichts zu suchen.

int main ()
{
teilnehmer t1 ("Kevin", 123456, "Mueller");
t1.print();
teilnehmer t2 ("Franz", 112233, "Schuhmacher");
t2.print();
teilnehmer t3 ("Lisa", 102356 , "Fritz");
t3.print();
teilnehmer t4 ("Manfred", 258963, "Schmitt");
t4.print();
return 0;
}

Die mit Anführungszeiche eingeschlossenen Namen sind sogenannte "Stringliterale". Sie sind vom Compiler automatisch erzeugte Arrays mit statischer Lebenszeit vom Typ [c]const char[N][/c], wobei N jeweils für die Länge der Zeichenkette plus eins (wegen Nullterminierung) steht. Dein Konstruktor erwartet aber Zeiger auf **nicht-**const char. Diese Konvertierung ist zwar (noch) aus Kombatibilitätsgründen zu C zulässig, aber unerwünscht und schlecht ("deprecated").

Definieren Sie die Tabelle der 16 Teilnehmer als ein Array aus Objekten der Klasse
„Teilnehmer“. Befüllen Sie die ersten 4 Objekte mit einer Initialisierungsliste. Die
restlichen 12 Objekte wird der Standardkonstruktor befüllen.
Bauen Sie für das Ausgeben eine geeignete Schleife.

Das war wahrscheinlich so gemeint:

int main() {
  Teilnehmer tabelle[16] = {
    {"Karl", "Meier"},
    {"Uwe", "Schmidt"},
    {"Otto","Mustermann"},
    {"Ute","Obermeier"}
  };
}

Allerdings funktioniert diese Syntax nur, falls Teilnehmer ein sogenannter Aggregat-Typ ist. Ein Aggregat-Typ hat aber (per Definition) keine benutzerdefinierten Konstruktoren oder Destruktoren, keine nicht-statischen Elemente, und nur öffentliche Elemente (public:) -- wenn ich mich richtig erinnere. Die Formulierung deines Lehrers "restlichen 12 Objekte wird der Standardkonstruktor befüllen" ist etwas ungünstig, da ints und char-Arrays und damit auch Aggregate, die nur aus ints und char-Arrays bestehen, keine "Standardkonstruktoren" haben, die das machen würden, was Dein Lehrer erwartet. Hier, bei dieser Initialisierungssyntax, wird eine sogenannte "zero initialization" für all die restlichen Elemente durchgeführt. Das ist eine von mehreren wissenswerten Sonderregeln, die das Lernen von C schwer machen.

Daten:
· Das Programm soll die Daten von max. 16 Teilnehmern verwalten.
· Pro Teilnehmer werden Nachname, Vorname und Matrikelnummer verwaltet.
Ausgabe:
· Das Programm soll eine Teilnehmerliste ausgeben, in Form einer Tabelle wie folgt:
· Es soll die Spalten „Name“, „Vorname“ und „Matrikelnummer“ geben.
· Zunächst muss eine passende Überschrift ausgegeben werden.
· Dann folgen so viele Zeilen, wie es Teilnehmer gibt, für die Daten eingegeben
wurden.
Definieren Sie eine Klasse „Tellnehmer“ mit den Datenelementen
· 30 Zeichen Vorname,
· 30 Zeichen Nachname und
· einer Integer Matrikelnummer.
Programmieren Sie Konstruktoren für diese Klasse:
· Einen Standard-Konstruktor, der den Vornamen mit dem Nullstring initialisiert und
den Nachnamen den String “-“, sowie die Matrikelnummer auf 0 setzt.
· Einen zweiten Konstruktor mit 3 Parametern; zwei Parameter sind Strings für
Nachnamen und Vornamen, der dritte eine Integer für die Matrikelnummer.
· Evtl. können Sie beide Konstruktoren durch die Verwendung von Vorgabewerten
zu einem Konstruktor zusammenfassen.
Erstellen Sie eine Methode „print()“ für diese Klasse , die eine Zeile der Tabelle
schreibt, wenn es sich nicht um ein „leeres“ Objekt im Array handelt (Nachname “-“).
Verwenden Sie für die Ausgabe der Daten den stream „cout“. Alternativ können Sie
auch die aus C bekannte Funktion printf() verwenden.

**

Was char vorname[30] und char nachname[30] betrifft, ich glaube mann muss definieren wie groß der String ist oder irre ich mich?
eine kleine Frage hätte ich noch, warum muss ich einen Zeiger benutzen?

Die Formulierung deines Lehrers "restlichen 12 Objekte wird der Standardkonstruktor befüllen" ist etwas ungünstig, da ints und char-Arrays und damit auch Aggregate, die nur aus ints und char-Arrays bestehen, keine "Standardkonstruktoren" haben, die das machen würden, was Dein Lehrer erwartet. Hier, bei dieser Initialisierungssyntax, wird eine sogenannte "zero initialization" für all die restlichen Elemente durchgeführt.

Ich korrigiere: Es handelt sich um eine "Default-Initialisierung" der restlichen Elemente (was aber im Fall von int und char auf eine "zero initialization" hinaus läuft). Das gilt auch für POD-Aggregate, die keine vom Compiler implizit erzeugten Konstruktoren haben.

Zitat aus dem C++ Standard, §8.5.1/7:

If there are fewer initializers in the list than there are members in the aggregate, then each member not explicitly initialized shall be default-initialized.

wobei default-initialized so definiert wird, §8.5/5:

To default-initialize an object of type T means:
- if T is a non-POD class type (clause 9), the default constructor for T is called (and the initialization is ill-formed if T has no accessible default constructor);
- if T is an array type, each element is default-initialized;
- otherwise, the object is zero initialized;

zero-initialization steht gleich darüber erklärt. Ich spare mir das zitieren aber. Es ist wahrscheinlich sowieso Overkill. Aber es macht zumindest deutlich, dass es relativ viele Regeln gibt, die man nur durch Rumprobieren schlecht erraten kann.

Bei der Gelegenheit verweise ich auch noch auf camper's Post "Kleine Taxonomie für Typen".

So ich glaube es gibt einen Missverständniss was das hier betrifft:
vorname [30] = '0';
das hat der professor so verlangt (denke ich zumindest).

Bestimmt nicht.

pava schrieb:

so hier ist die aufgabe damit keine missverständnise mehr vorkommen
[...]

Ich sehe da keine Bemerkung zur Art der Initialisierung. Aber nachdem, was er verlangt, kann die Klasse Teilnehmer kein Aggregat-Typ mehr sein. Ein Array davon müsste sich aber immernoch ähnlich initialisieren lassen:

int main() {
  Teilnehmer liste[16] = {
    Teilnemher("Hinz", "Kunz", 1234),
    Teilnemher("Dings", "Bums", 4321)
  };
}

pava schrieb:

Was char vorname[30] und char nachname[30] betrifft, ich glaube mann muss definieren wie groß der String ist oder irre ich mich?

Ja, is ja auch richtig. Aber das [30] gehört nicht zum Namen des Arrays dazu. Ich weiß nicht, warum Du glaubst, dass das [30] überall sonst noch dazugeschrieben werden muss.

pava schrieb:

eine kleine Frage hätte ich noch, warum muss ich einen Zeiger benutzen?

Wenn Du einen Konstruktor schreiben willst, der Deine Arrays befüllt, müsstest Du dich mit Funktionen wie sie im Header <cstring> zu finden sind, rumärgern. Diese Funktionen arbeiten mit Zeigern. Das sind Funktionen, die zB die Länge von C-Strings berechnen (Nullterminierung suchen), einen C-String kopieren, etc etc etc. Alles Käse eigentlich, wenn Du nicht std::string benutzen darfst. Käse, weil es damit relativ einfach wird, sich in den Fuß zu schießen.

Ich rate Dir, das, was der Prof erzählt, kritisch zu betrachten und in dem einen oder anderen guten Lehrbuch nachzuschlagen. Es mag nur sein didaktischer Plan sein, dass die Studenten sich mit C-Strings rumärgern sollen, bevor sie std::string kennenlernen und dann die Vorzüge richtig zu schätzen wissen. Es kann aber auch sein, dass der Prof von C++ nicht ganz so viel Ahnung hat, und Euch in Wirklichkeit "C mit Klassen" beibringt, ohne zu erwähnen, dass man sich mit Klassen (und eigenen Kopierkonstruktoren, Destruktoren, Zuweisungsoperatoren, überladenen Operatoren) ganz nette und leicht benutzbare eigene Typen bauen kann (wie zB std::string), auf die man aufbauen kann. Das Stichwort hier ist Abstraktion und Kapselung. Sorry, ich habe keine Lust, mir jedes Mal Gedanken zu machen, ob mein char-Array auch groß genug ist, und wie ich am besten Zeichenketten ohne Pufferüberläufe kopiere. Der eingefleischte C-Programmierer mag das anders sehen, doch auch in Projekten von C++-Hassern findet man Abstraktionsansätze für Zeichenketten, die auf so etwas ähnliches wie std::strig hinauslaufen -- nur dass man immer noch recht viel bei dem aufpassen muss, was man da tut; denn es gibt ja keine Kopierkonstruktoren, Destruktoren und überladene Zuweisungsoperatoren in C.

char vorname [0] = '0';

vielen dank an alle die mir geholfen haben , ich bin jetzt dank eure hilfe einbischen schlauer geworden, und weiss teilweise was für Fehler ich gemacht habe. Den Rest muss ich wie ihr das gesagt habt in meinem Buch noch lesen. Ich habe das Buch go to c++. ist das Buch ok? ich finde manchmal könnten ein paar mehr Beispiele nichts schaden.
ach ja noch etwas, wäre es denn richtig so ?

char vorname [0] = '0';

Wenn du aus dem String einen Leerstring machen willst, muss es so aussehen:

char vorname [0] = 0;

Das Stringende wird von einer binären Null signalisiert, nicht von dem Zeichen '0' (dann dürfte in deinen Strings ja nie '0' vorkommen, was dich leicht einschränken würde ).

Den Rest muss ich wie ihr das gesagt habt in meinem Buch noch lesen. Ich habe das Buch go to c++. ist das Buch ok?

Das kenne ich nicht. Es klingt vom Titel her aber nicht so vielversprechend.

pava schrieb:

ich finde manchmal könnten ein paar mehr Beispiele nichts schaden.
ach ja noch etwas, wäre es denn richtig so ?

char vorname [0] = '0';

Nein. Das sollte gar nicht kompilieren; denn Du definierst hier ein Array mit 0 Elementen. Und mit "definieren" meinte ich das, was vor dem Gleich steht. Das ab dem Gleich ist die Initialisierung, die auch noch falsch gewesen wäre.

Beispiel, welches Du sehen willst, aber wegen dem char-Array eigentlich etwas frickelig ist:

#include <iostream>
#include <cstring>

const int name_feld_laenge = 30;

class person
{
  char name_[name_feld_laenge];
public:
  person() { name_[0] = '\0'; }
  explicit person(const char* zeiger);
  const char* name() const { return &name_[0]; }
};

person::person(const char* zeiger)
{
  std::strncpy(&name_[0],zeiger,name_feld_laenge);
  // strncpy garantiert aber keine Nullterminierung im Ziel
  // Wir müssen daher Hand anlegen:
  name_[name_feld_laenge-1] = '\0';
}

int main() {
  person liste[3] = {
    person("Heinz ist nett und dieser String ist zu lang"),
    person("Uwe")
  };
  std::cout << liste[0].name() << '\n';
  std::cout << liste[1].name() << '\n';
}

wobei es dies hier eigentlich auch getan hätte:

#include <iostream>
#include <string>

struct person
{
  std::string name;
};

int main() {
  person liste[3] = {
    {"Heinz ist nett und dieser String ist nicht zu lang"},
    {"Uwe"}
  };
  std::cout << liste[0].name << '\n';
  std::cout << liste[1].name << '\n';
}

Nur das will Dein Prof nicht sehen, weil er entweder denkt, es sei besser C vor C++ zu lernen oder weil er nicht weiß, wie "schönes" C++ aussehen kann.

Die Sachen aus der Standardbibliothek (std::string, std::strncpy, etc) kann man zB hier nachgucken.

#include <iostream>
#include <cstring>
using namespace std;

class teilnehmer
{
private :
    char vorname [30] ;
    char nachname [30];
    int matrikelnummer;
public:
    teilnehmer ();
    teilnehmer (char v[30], int m, char n[30]);
    void print ();
};

teilnehmer :: teilnehmer ()
{
vorname [0] = 0;
nachname [0] = '-';
int matrikelnummer = 0;
}

teilnehmer :: teilnehmer(char v [30], int m, char n[30])
{
vorname [30] = v [30];
matrikelnummer = m;
nachname [30] = n [30];

}

void teilnehmer :: print ()
{

    if (nachname [0]  != '-')
    {
        cout << "Der Nachname ist : " << nachname  << endl;
    }
}

int main ()
{
	teilnehmer tabelle[16] = {
    teilnehmer  ("Kevin", 123456, "Mueller"),

    teilnehmer  ("Franz", 112233, "Schuhmacher"),

    teilnehmer  ("Lisa", 102356  , "Fritz"),

    teilnehmer  ("Manfred", 258963, "Schmitt"),
	};
int i;
for (i=0 ; i<16 ; i++)
{
	/*das Programm kann man Fehlerfrei kompilieren wenn 
     man die cout hier unten nicht benutz, aber ich brauche 
	 die ausgabe, kann mir jemand bitte zeigen wie die ausgabe richtig wäre?*/
	cout << tabelle [i].vorname << endl;
	cout << tabelle[i].matrikelnummer << endl;
}
    return 0;
}

pava schrieb:

teilnehmer (char v[30], int m, char n[30]);

müsste tatsächlich heißen:

teilnehmer (const char v[30], int m, const char n[30]);

wobei die 30 eigentlich überflüssig ist. Man könnte auch const char[] dafür schreiben -- kommt auf dasselbe raus. v und n sind nuneinmal Zeiger hier und keine Arrays -- wegen der angesprochenen Typtransformation.

pava schrieb:

void print ();

Hier fehlt ein const am Ende. Sollte so aussehen:

void print () const;

(Die Funktion print muss/will den Zustand des Objekts nicht ändern.)

pava schrieb:

teilnehmer :: teilnehmer(char v [30], int m, char n[30])
{
vorname [30] = v [30];
matrikelnummer = m;
nachname [30] = n [30];
}

Man hat Dir schon erklärt, dass das hier sinnfrei ist, was Du machst. Ich habe Dir sogar schon gezeigt, wie man die C-Strings hier richtig kopieren würde. Das [30] hier ist immer noch Nonsense. Klar, es lässt Dich Dein Programm kompilieren, aber es ergibt keinen Sinn. Es macht nicht das, was Du willst. Du willst eine Kette von Zeichen kopieren, maximal 30 (einschließlich Nullterminierung). Was Du machst, ist das 31. Zeichen kopieren, welches im Falle von vorname und nachname nicht existiert, weil Du ja nur 30 Zeichen hast und welches im Falle von v und n auch nicht existieren muss. Du popelst also in einem Speicher rum, der Dir nicht gehört und von dem Du nicht weißt, dass es ihn überhaupt gibt. --> undefiniertes Verhalten

pava schrieb:

void teilnehmer :: print ()

hier kommt auch noch ein const an's Ende.

pava schrieb:

for (i=0 ; i<16 ; i++)
{
    /* das Programm kann man Fehlerfrei kompilieren wenn 
       man die cout hier unten nicht benutz, aber ich brauche 
       die ausgabe, kann mir jemand bitte zeigen wie die ausgabe
       richtig wäre? */
    cout << tabelle .vorname << endl;
    cout << tabelle[i].matrikelnummer << endl;
}

Dass man es fehlerfrei kompilieren kann, heißt nicht, dass der Rest in Ordnung ist. Natürlich kannst Du auf [i]private* Elemente nicht ohne weiteres zugreifen. Das ist ja der Witz von private. Wozu hast Du die print-Funktion? Außerdem solltest Du den Konstanten einen Namen geben, so dass Du sie ändern kannst, indem Du Dein Programm nur an einer Stelle ändern musst.

const int max_teiln = 16; // <-- eine Stelle. Diese 16 taucht sonst
                          // nirgens mehr auf, nur der Name max_teiln
teilnehmer tabelle[max_teiln] = {
   u.s.w.
};
for (int i=0; i<max_teiln; ++i) {
   tabelle[i].print();
}

@ Krümelkacker:
sorry ich wollte nicht das es so rüber kommt. Natürlich habe ich eure Ratschläge ernst genommen, aber ich habe mich halt gefreut als ich das programm Fehlerfrei kompilierte, aber jetzt weiss ich dass das nicht viel heisst.

der code musste also so aussehen, wenn ich dich dieses mal richtig verstanden habe:

teilnehmer :: teilnehmer(const char v [], int m, const char n[])
{
vorname [0]  = v [0]  ;
matrikelnummer = m;
nachname [0] = n [0] ;

somit greife ich jetzt auf das erste Element zu. richtig?

Gruß pava.

teilnehmer :: teilnehmer(const char v [], int m, const char n[])
{
vorname [0]  = v [0]  ;
matrikelnummer = m;
nachname [0] = n [0] ;

somit greife ich jetzt auf das erste Element zu. richtig?

Genau. Und dahinter steht immer noch Müll drinnen...
Ein Array besteht nämlich meistens aus mehr als nur einem Element und du willst doch sicherlich alle Elemente kopieren. Und auch dazu hat dir krümelkacker schon die Lösung präsentiert: std::strncpy.

#include <iostream> 
#include <string> 
using namespace std; 

class teilnehmer 
{ 
private : 
    string vorname ; 
   string nachname ; 
    int matrikelnummer; 
public: 
    teilnehmer (); 
    teilnehmer (string v, int m, string n); 
    void print (); 
}; 

teilnehmer :: teilnehmer () 
{ 
vorname  = ""; 
nachname  = "-"; 
matrikelnummer = 0; 
} 

teilnehmer :: teilnehmer(string v, int m, string n) 
{ 
vorname  = v ; 
matrikelnummer = m; 
nachname  = n ; 

} 

void teilnehmer :: print () 
{ 
	if (nachname   != "-") 
    {
		cout << "Der Vorname : " << vorname << " und die Matrikelnummer ist : "<< matrikelnummer << endl;
		cout <<	"Der Nachname ist : " << nachname  <<endl;      
    } 
} 

int main () 
{ 
    teilnehmer tabelle[16] = { 
    teilnehmer  ("Kevin", 123456, "Mueller"), 

    teilnehmer  ("Franz", 112233, "Schuhmacher"), 

    teilnehmer  ("Lisa", 102356  , "Fritz"), 

    teilnehmer  ("Manfred", 258963, "Schmitt"), 
    }; 
int i; 
for (i=0 ; i<16 ; i++) 
{ 
    tabelle[i].print();
}; 
    return 0; 
}

so ich glaube jetzt gibts nichts mehr zu meckern oder? ausser bei

const int max_teilnehmer = 16;

danke schön nochmal und bis zum nächsten Programm.

MfG Pava

• Formatierung - Formatier deinen Code anständig! Das ist schreklick zu lesen!
• Nutze Initialisierungslisten

Da gibts noch zwei Sachen, die mir gerade so aufgefallen sind:

• Formatierung - Formatier deinen Code anständig! Das ist schreklick zu lesen!
• Nutze Initialisierungslisten

Sry ich bin Anfänger, wie meinst du das mit der Formatierung?

Wenn ein neuer Block mit { beginnt, rückst du eine Ebene mehr ein, bei } eine weniger. Dadurch sieht der Code schon viel lesbarer aus.

Sry ich bin Anfänger, wie meinst du das mit der Formatierung?

Einrückung, diese auch konsistent durchziehen.
Die ";" ebenso konsistent setzen.
Keine unnötigen Leerzeilen und Leerzeichen.
USW.