avr studio 6.1 c++ classes

[micro u. (Gast)]

hallo
ich würde gerne c++ classen programmieren um servos anzusteuern.
somit könnte ich fertige servo objekte erstellen.

nun, ich stelle mir darunter sowas vor:

class Servo{
  // class private member
  double iniPos;
public:
  //constructor 
  Servo(double iniPos):iniPos(iniPos){
  }
  //methods
  void goTo(double pos){
    // do something
  }
  void turn(double angle){
    // do something
  }
};

avr studio 6.1 schlägt mir aber folgende files vor, wenn ich ein 
klasen-file hinzufüge:

CServo.h

#ifndef __CSERVO_H__
#define __CSERVO_H__


class CServo
{
//variables
public:
protected:
private:

//functions
public:
  CServo();
  ~CServo();
protected:
private:
  CServo( const CServo &c );
  CServo& operator=( const CServo &c );

}; //CServo

#endif //__CSERVO_H__

CServo.cpp

#include "CServo.h"

// default constructor
CServo::CServo()
{
} //CServo

// default destructor
CServo::~CServo()
{
} //~CServo

- wie muss ich diese files nun bearbeiten, um ans ziel zu kommen?
soweit ich verstanden habe ist ja die .h nur dazu da die "verweise" zu 
machen, den gesammten code jedoch schmeiss ich dann in die .cpp.
Ich würde jetzt alle meine member die ich will in der .h anlegen und 
alle methoden in der .cpp programmieren, construktor werden nicht genau 
so gemacht wie ich das gelernt habe, also so sein lassen oder fehlt da 
noch was?

- das protected ist mir neu, was is da die funktion? public ersichtlich 
aber nur private beschreibbar? Oo

[micro u. (Gast)]

ich würd das jetzt so schreiben:

.h

#ifndef __CSERVO_H__
#define __CSERVO_H__


class CServo
{
//variables
public:
protected:
private:
// class private member
double iniPos;

//functions
public:
  CServo();
  ~CServo();
protected:
private:
  CServo( const CServo &c );        // was ist das?
  CServo& operator=( const CServo &c );  // was ist das?

}; //CServo

#endif //__CSERVO_H__

.cpp

#include "CServo.h"

// default constructor
CServo::CServo()
{
} //CServo

// default destructor
CServo::~CServo()
{
} //~CServo

// methodes
void goTo(double pos){
  // do something
}
void turn(double angle){
  // do something
}

[Kaj (Gast)]

micro uc schrieb:
> das protected ist mir neu, was is da die funktion? public ersichtlich
> aber nur private beschreibbar?

Stichwort: Vererbung bzw. ich nenne es mal "zugriffsrechte"

Eine funktion aus dem private-Bereich kannst du nur innerhalb der Klasse 
aufrufen, aber nicht in einer Funktion außerhalb der Klasse.

Google und ein bisschen ausprobieren ist da ganz hilfreich ;)

Grüße

[Oliver (Gast)]

micro uc schrieb:
> avr studio 6.1 schlägt mir aber folgende files vor, wenn ich ein
> klasen-file hinzufüge:

Wie du ganz richtig erkannt hast, ist das nichts weiter als ein 
Vorschlag. Wenn dir das nicht gefällt, dann lösch einfach alles, was da 
steht, und schreib hin, was du für richtig hälst.

Ein C++-Buch wäre allerdings auch zu empfehlen...

Oliver

[micro u. (Gast)]

hallo
ja wie erwähnt, private und public ist mir bekannt. das protected is die 
frage. aber nebensache. mich interessiert hauptsächlich der aufbau der 
classe in den beiden files!

[micro u. (Gast)]

@oli
kann ich dann alles in die .h packen und das mit dem zusatzfile .cpp 
sein lassen?

[Karl H. (kbuchegg)]

micro uc schrieb:
> hallo
> ja wie erwähnt, private und public ist mir bekannt. das protected is die
> frage. aber nebensache. mich interessiert hauptsächlich der aufbau der
> classe in den beiden files!

Tja.
Das Problem ist, das man dir jetzt einen Vortrag halten müsste, der sich 
in einem C++ Buch über gut und gerne mindestens 20 Seiten erstreckt.

Das man mehrere Konstruktoren haben kann, wirst du wahrscheinlich 
wissen. Einer davon ist ein Default Konstruktor, der immer dann benutzt 
wird, wenn keine weiterern Parameter an den Konstruktor zu übergeben 
sind.

Das ist der hier

  CServo();

Er kommt zb dann zum Einsatz, wenn einfach nur 1 Objekt erzeugt werden 
soll

int main()
{
  CServo meinServo;       // Default Konstruktor wird aufgerufen

Ein anderer Konstruktor ist der hier

  CServo( const CServo &c );        // was ist das?

das ist ein Copy-Konstruktor. An und für sich ein Konstruktor wie jeder 
andere, also auch wie deiner hier

  Servo(double iniPos)

nur mit dem Unterschied, dass er eine Referenz auf ein Objekt vom 
gleichen Typ nimmt. D.h. er wird dann eingesetzt, wenn es gilt, eine 
Kopie von einem Objekt zu machen
zb hier

int main()
{
  CServo ServoA;
  CServo ServoB( ServoA );

ServoB ist also eine exakte Kopie vom ServoA.
OK, in dieser Form ist das natürlich Unsinn und das wird so kein Mensch 
machen. Aber an anderen Stellen kommt es schon vor, dass man eine Kopie 
von einem Objekt braucht. Denke zb daran, was passieren muss, wenn man 
ein Objekt in einen Container einfügt. Dann gibt es 2 Möglichkeiten: 
entweder man fügt eine Referenz auf das Originalobjekt in den Container 
ein, oder man erzeugt eine Kopie vom Originalobjekt und fügt das in den 
Container ein. Die erste Variante hat den Nachteil, dass dann das 
Originalobjekt weiter bestehen muss, solange es eine Referenz davon im 
Container gibt. Bei der 2.ten Varianten hab ich dieses Problem nicht. 
Denn das Originalobjekt braucht keiner mehr, nachdem die Kopie gezogen 
wurde. D.h. das Originalobjekt kann auch zerstört werden, das betrifft 
die Kopie nicht.

Aber auch hier

void foo( CServo a )
{
  ...
}

int main()
{
  CServo b;

  foo( b );
}

wird eine Kopie erzeugt. innerhalb von foo ist a eine Kopie von b. Und 
erzeugt wird diese Kopier durch den Aufruf des Copy Konstruktors ehe 
dann der Funktionsaufruf der Funktion foo gemacht wird und der dann 
diese Kopie übergeben wird.

Das hier

  CServo& operator=( const CServo &c );  // was ist das?

ist der Zuweisungsoperator. Er hat eine ähnliche Aufgabe wird allerdings 
bei Zuweisungen eingesetzt

int main()
{
  CServo ServoA;
  CServo ServoB;

  ServoB = ServoA;
}

An der Stelle der Zuweisung wird zum Zwecke der Durchführung der 
Zuweisung genau diese Funktion aufgerufen. Ihre Aufgabe ist es, im 
Original von B alles zu tun, was es zu tun gibt um das bisherige B 
Objekt aufzulösen und die Werte vom A Objekt nach B zu übernehmen.


Soweit so gut.
Aber was hat es jetzt mit dem private auf sich?

Das ist ganz einfach.
Alle Member-Funktion, die private definiert sind, können nur von 
innerhalb genau dieser Klasse benutzt werden. D.h. mit obiger 
vorgeschlagener Funktion geht das gar nicht

void foo( CServo a )
{
  ...
}

int main()
{
  CServo ServoA;
  CServo ServoB( ServoA );

  foo( ServoA );

den weder main noch foo sind Teil der Klasse. Der Copy Konstruktor ist 
aber ausserhalb der Klasse nicht zugreifbar! Der Compiler muss dir das 
also verbieten. Mit anderen Worten: die Klasse hat sich selbst davor 
geschützt, dass irgendein anderer Code je eine Kopie eines Objektes 
machen kann. Man kann Objekte anlegen, mann kann sie auch zerstören, 
aber kopiern ... no, no ... das geht nicht.

Selbiges mit dem Zuweisungsoperator. Auch der ist private. Und damit 
sind dann auch alle derartigen Zuweisungen

   ServoB = ServoA;

nicht compilierbar.

Effektiv hat damit die Klasse ihrem Verwender eine Schranke auferlegt, 
was er tun darf und was nicht.

Warum man das in manchen Fällen haben will .... das ist eine andere 
Geschichte, die allerdings noch umfangreicher zu erzählen ist und worauf 
ich momentan ehrlich gesagt keine Lust habe. Denn dazu gibt es C++ 
Bücher.

[Karl H. (kbuchegg)]

micro uc schrieb:
> @oli
> kann ich dann alles in die .h packen und das mit dem zusatzfile .cpp
> sein lassen?


Warum willst du das tun?
Was hat das damit zu tun, was dir der Wizard vorgeschlagen hat?

[micro u. (Gast)]

um es einfach zu halten würd ich somit meinen vorgeschalgenen code 
verwenden und da drin alles programmieren, anstatt den vorschlag zu 
benutzen.

[Karl H. (kbuchegg)]

Um es einfach zu sagen, unterscheidet sich deine Klasse bis auf 1 
kleines Detail praktisch in nichts vom Vorschlag.
Und das kleine Detail ist: der Vorschlag hat für dich mitgedacht und 
greift dir ein wenig unter die Arme, in dem er potentiell gefährliche 
Operationen (kopieren und zuweisen) erst mal unterbindet, solange du 
nicht weißt, welchen Ärger du dir damit einhandeln kannst. Und er macht 
das so, dass diese Unterbindung auch dann greift, wenn du selbst mglw. 
gar nicht merkst, dass du unabsichtlich eine Kopie ziehst. Wie zb durch 
ein vergessenes & in der Argumentliste einer Funktion.

[Karl H. (kbuchegg)]

Ob du die Implementierung der Methoden hingegen in ein eigenes cpp File 
auslagerst, oder ob du die Funktionen direkt im Header File inline 
implementierst, ist ein Detail, dass sich beim Funktions-inlining an der 
Aufrufstelle auswirkt. Mehr aber auch nicht.
Und ob der COmpiler tatsächlich inlined oder nicht - das entscheidet der 
sowieso selber. Eine inline angegebene Methode ist ein Vorschlag an den 
Compiler zum inlinen. Aber es ist für ihn keine Verpflichtung.

Üblicherweise macht man kurze Funktionen (typischerweise die Getter und 
Setter) direkt inline in der Klassendefinition im Header File und den 
ganzen Rest an umfangreicheren Funktionen im cpp File.

Wenn es das ist, was du wissen willst.

[micro u. (Gast)]

okay super. vielen dank für die erklärungen!
wer ich mal so versuchen umzusetzen.

thread closed.