includes..

class Personal[5]
{
    char name[15];
};

void unterprogramm(Personal &)

int main
{
    Personal namen;
    unterprogramm(namen);
}

void unterprogramm(Personal &namen)
{
    cout << namen[0].name[0];
}

die klasse muss ein Feld sein. ich brauche dass für meine Adressdatenbank. leider weis ich noch nichts über klassen-felder. kann mir jemand helfen.. bitte.

class Personal[5]
{
    char name[15];
};

Das muss so aussehen:

class Personal
{
    char name[15]; //std::string wäre besser, aber jetzt egal
};

Stelle dir mal vor du hast ein Array vom Typ int, dann machste das ja so:

int meinArray[10]

Und folglich ist die Syntax bei deiner Klasse genauso.

Personal myOB; // für nur ein Objekt
Personal myArrayOB[10] // für ein Array von Personal Objekten

weiter...

void unterprogramm(Personal &)

Erstmals fehlt hier das Semikolon und zweiter sollte dein Parameter einen Namen haben:

void unterprogramm(Personal &namen);

In der main dann würde ich mal ein return reinpacken

Und jetzt was ganz böses was du gemacht hast:

void unterprogramm(Personal &namen)
{
    cout << namen[0].name[0];
}

Auch wenn das jetzt da mit den Array nicht stimmt versuchst du hier auf eine Private variable(name) zuzugreifen.
In einer Klasse sind alle Elemente standardmäßig privat nicht so wie in Unions oder Strukturen öffentlich(public).

Du müsstest also name public machen was aber seeeeeeeeeeeeeeeeeeeeeeeeehhhhhhhhhr bäse ist und name zur Klasse gehört und so vor Außenangriffen geschützt werden muss.
Deswegen muss du eine Elementfunktion bereitstellen die dich diese Variable sehen lässt.

Also sollte deine Klasse so aussehen:

class Personal
{
    char name[15];
public:
    void showname();
};

Jetzt brauchst du nicht mehr diese andere blöde Funktion, sondern hast deine eigene Elementfunktion auf die du von außen zugreifen kannst und diese wiederum auf name zugreifen kann.(och wie schön oder :D)

Zum Schluss sollte das dann so aussehen:

class Personal
    char name[15];
public:
    void showname();
};

void Personal::showname()
{
     cout <<name;
}

int main()
{

    Personal namen;
    namen.showname();

 return 0;
}

Etwas fehlt dir aber leider noch, nämlich ein Konstruktor womit du name initialisieren kannst. Aber das verrat ich dir jetzt nicht, denn Rest musst du selber lernen

leider weis ich noch nichts über klassen-felder. kann mir jemand helfen.. bitte

--> Du solltest lieber noch mal erst intensiv die Grundlagen über Klassen lernen

ABER: bei dem prototypen gibt man doch nur var-typ ohne var-namen an...

class Personal {public: char vname[20];};
...
void unterprogramm(Personal &);
...
in main()
{...
    Personal namen[5];
    unterprogramm(namen);
}

void unterprogramm(Personal &namen[])
{...}

Hierbei geht es mir auch um die Übergabe Parameter des Objektfeldes.

stimmt das so..?

ABER: bei dem prototypen gibt man doch nur var-typ ohne var-namen an...

Vollkommen egal, kannst sowohl mit als auch ohne Bezeichner deklarieren.

serprime schrieb:

Hierbei geht es mir auch um die Übergabe Parameter des Objektfeldes.

stimmt das so..?

Nicht ganz.

template <size_t N>
void unterprogramm(const Personal (&namen)[N])

Vollkommen egal, kannst sowohl mit als auch ohne Bezeichner deklarieren.

Man kann sogar verschiedene Bezeichner bei Prototypen und Implementationen verwenden. Sinn macht das zwar keinen aber der compiler wertet bei den prototypen sowiso nur die typinformation aus.
Kurt

@grovemaster:
kannst du mir das mit dem template erklären. und warum ich die klammern brauche.
also ich bin jetzt leicht verwirrt.

das kann doch nicht so schwer sein ein objekt-feld zu übergeben

liebe grüße serprime

hab ich schon erwähnt, dass ich in der 3. klasse wirtschaftsinformatik bin?? wir haben mit klassen erst begonnen.. aber ich wills wissen. kann mir das bitte jemand so erklären dass ich damit was anfangen kann??

verzweifelte grüße serprime

void unterprogramm(const Personal namen[])
// oder
void unterprogramm(const Personal* namen)

schreiben. Nur ist dann namen eben ein Zeiger, und kein richtiges Array mehr. Sofern dies nicht notwendig ist, ist diese Schreibweise für dich evtl. sinnvoller.

Die Templatisierung ist nur dann sinnvoll, wenn du eben ein builtin Array hast, welches unterschiedlich gross sein kann. Ansonsten kannst du das auch weglassen.

void unterprogramm(const Personal (&namen)[5])

Was die Klammerung betrifft, nun, das wird halt von C++ syntaktisch so verlangt. Da die eckigen Klammern Vorrang haben, würde das vom Compiler sonst als

void unterprogramm(const Personal &(namen[5]))

ausgewertet werden, was nicht korrekt wäre.

ein Array wird in C und C++ immer als Zeiger übergeben, d.h. per Referenz funktioniert nicht.

Richtig muß es heißen:

void unterprogramm(Personal namen[]) // oder auch (Personal *namen)
{
   namen[0].showname();
}

Leider weiß jetzt das "unterprogramm" die Größe des Arrays nicht.
Daher entweder noch übergeben, also

void unterprogramm(Personal namen[], size_t size)
{
   for(size_t i = 0; i<size; i++)
     namen[i].showname();
}

Oder noch besser die STL verwenden:

typedef std::vector<Personal> VPersonal;

void unterprogramm(const VPersonal &namen) // jetzt Übergabe als konstante Referenz auf vector
{
   for(size_t i = 0; i<namen.size(); i++)
     namen[i].showname();
}

In der Main dann den Vector initialisieren:

int main()
{
   VPersonal namen;

   Personal p("Th");
   namen.push_back(p);

   p.SetName("Horst");
   namen.push_back(p);

   unterprogramm(namen);

Jetzt mußt du nur noch den Konstruktor von Personal sowie die Methode SetName definieren...

class Personal
{
   std::string sName;  // <-- std::string ist besser als char*
public:
  Personal(const std::string &name)
    : sName(name)   // <-- hier Initialisierungsliste
  {}

  void SetName(const std::string &name)
  {
    sName = name;  // <-- hier einfach string kopieren
  }
}

So, für diese Lehrstunde berechne ich 15,- -)

ein Array wird in C und C++ immer als Zeiger übergeben, d.h. per Referenz funktioniert nicht.

In C nicht, in C++ schon.

hier das schema:

#include <iostream>
using namespace std;

class MyClass {
public:
	int iTest;
	void MyClass();
};

MyClass::MyClass()
{
	iTest = 5;
}

void TestFunktion(MyClass *pTest)
{
	pTest[1].iTest = 7;
}

int main(void)
{
	MyClass Bertel[2];
	Bertel[1].iTest = 6;
	cout << "Bertel 1: " << Bertel[0].iTest << endl;
	TestFunktion(Bertel);
	cout << "Bertel 2: " << Bertel[1].iTest << endl;

	return EXIT_SUCCESS;
}

Seit wann haben Konstruktoren Rückgabewerte. Und wenn eh alles öffentlich in der Klasse ist dann benutzt doch lieber struct und nicht class...........

serprime schrieb:

#include <iostream>
using namespace std;

class MyClass {
public:
	MyClass():iTest(5){}//Initialisierungsliste statt zuweisung im c-tor.
	void set(const int i){iTest=i;}//setzt den wert des obj auf übergebenes i
    const int get()const{return iTest;}// gibt den wert der obj-var zurück , zB für ausgaben wie unten
private:
	int iTest;//damit das Atribut privat sein kann : public get methode.
};

int main()
{
	MyClass Bertel[2];
	Bertel[1].set(6);
	cout << "Bertel 1: " << Bertel[0].get() << endl;
	Bertel[1].set(7);
	cout << "Bertel 2: " << Bertel[1].get() << endl;
	return 0;
}