Objekte[n] von einer Klasse erstellen

Quote:

Originally Posted by Hg(CNO)2 Aber meins wäre auch richtig oder? Laut dem Anfang deines Beitrags ,,Er könnte auch so aussehen:,, schließe ich nun ab, dass meine Form ebenfalls richtig ist.. Ich bin etwas schreibfaul um ehrlich zu sein umso kürzer umso besser^^

Konto::Konto(double 0.00/* Für den Anfangswert des Kontostands */)
// oder
Konto::Konto(/* Für den Anfangswert des Kontostands */)
{
double kontostand = 0.00}

void foo()
{
     //Die Variable lebt von hier:
      int bar = 0;

} //bis hier

//hier gibt es bar nicht mehr

class Foo
{
private:
     int mBar;

public:
     Foo();
     ~Foo();
};

Foo::Foo() :
     mBar(0)  //Wenn du mBar nicht initialisierst, dann kann alles mögliche in der Variable stehen
{
}

Foo::~Foo()
{
}

int main()
{
     { //Nur zur Demonstration, der Scope hat hier keinen Nutzen
          Foo foo; //mBar wurde mit der Klasse erstellt
     } //hier stirbt mBar mit foo

     //Hier gibt es foo und somit mBar nicht mehr
}

Quote:

Originally Posted by Hg(CNO)2 Soll ich #pragma once nur benutzen, wenn ich an der Stelle auch #ifndef/#define gemacht hätte? Im Internet habe ich grad keinen Nachteil darüber gelesen, außer dass einige Compiler #pragma once nicht unterstützen.

Quote:

Ist es irrelevant, ob man structs, unions oder class für die Klassen Definition verwendet? Abgesehen von den Voreinstellungen der jeweiligen Definitionsarten.

union FloatOderInt
{
    int x;
    float y;
};

FloatOderInt var;
var.x = 5;
var.y = 5.0f;

Quote:

2. Du kannst aus einem Konstruktor genau wie aus jeder Funktion eine Exception werfen, die einen Fehlerfall anzeigt. Wenn du vorher schon Heap Speicher alloziert hast, musst du den natürlich wieder freigeben, wenn du so eine Exception fängst.

Quote:

Originally Posted by MrSm!th (wobei meines Erachtens dann einfach das Design Schrott ist)

typedef unsigned char byte;

union word
{
	struct
	{
		byte low, high;
	};

	unsigned short value;
};

union dword
{
	struct
	{
		word low, high;
	};

	unsigned long value;
};

union qword
{
	struct
	{
		dword low, high;
	};

	unsigned long long value;
};

union color
{
	struct
	{
		byte b, g, r, a;
	};

	unsigned long value;
};

int main()
{
	qword someQword;
	someQword.value = 0xAABBCCDDEEFF0011;

	dword high = someQword.high, //0xAABBCCDD
		low = someQword.low; //0xEEFF0011

	word lower = low.low; //0x0011

	byte theLowest = lower.low; //0x11

	color someColor;
	someColor.value = 0xFFB000B5;
	//someColor.a => 0xFF
	//someColor.r => 0xB0
	//someColor.g => 0x00
	//someColor.b => 0xB5
}

void foo()
{
     if(false)
          std::cout << std::endl;

     while(true)
     {
          if(true)
          {
                break;
           }
     }
     std::cout << std::endl;
}

void kontostatus(Konto&);

void Konto::zeigeKontostand() //kontostatus ist kein geeigneter Name
{
     std::cout << this->kontoinhaber << "\n\t"
           << this->kontonummer << "\t" << this->bankleitzahl << "\n\t"
           << this->stand << std::endl;
}

Konto::Konto(double kontostand = 0.00,unsigned long bankleitzahl = 669503499)
{}

Konto::Konto(double kontostandNeu = 0.00,unsigned long bankleitzahlNeu = 669503499) : // : leitet die initializer list ein
     kontostand(kontostandNeu), //schreibt den Werten von kontostandNeu in das Attribut "kontostand"
     bankleitzahl(bankleitzahlNeu) //schreibt den Werten von bankleitzahlNeu in das Attribut "bankleitzahl"
{
}

class Foo
{
private:
     int mBar;
public:
     Foo(int bar) :
          mBar(bar)
     {
     }

     int getBar()
     {
          return mBar;
     }

     void setBar(int bar)
     {
          mBar = bar;
     }
};

int main()
{
     Foo fooUno(10);
     Foo fooDue(5);
     Foo fooTre(10);

     std::cout << fooUno.getBar() << std::endl;
     std::cout << fooDue.getBar() << std::endl;
     std::cout << fooTre.getBar() << std::endl;

     fooTre.setBar(-1);
     std::cout << fooTre.getBar() << std::endl;
}

Quote:

Edit:// Ich verstehe nicht ganz das Union im Speicher. Datenelemente die mit Union definiert wurden, bekommen die gleiche Speicherschnittstelle(Anfangsadresse halt kenn kein anderes Wort dafür ). Wie berechnet man da die Größe eines Objekts? Die Bitoperatoren habe ich auch nicht gerade sehr gut drauf... Hab mich aber auch nicht intesiv damit beschäftigt.

union useless
{
	float fValue;
	unsigned long ulValue;
};

int main()
{
	useless u;
	u.ulValue = 0x40a00000;
	std::cout << std::hex << u.fValue << std::endl;
}

union word  //1 word == 2 bytes
{
     struct
     {
          byte low;
          byte high;
     };
     unsigned short value;
};

10101010 11111111
Byte1      Byte2

im ram
11111111 10101010
low          high
0xAA        0xFF

Quote:

Originally Posted by Nightblizard Das kann ich so nicht stehen lassen. unions haben, wie jedes andere Mittel der Sprache, einen Grund, warum sie existieren. Und nur weil du ihn (noch) nicht kennst oder falsch kennen gelernt hast, heißt das nicht, dass das "Schrott" ist.

Quote:

Die obere Hälfte ist der so genannte high part und die untere hälfte der low part.

Quote:

Ich gebe ihm bewusst nicht die Lösung.

Quote:

Adresse nicht als unsigned short, sondern als zwei Bytes ausgewertet.

Konto::Konto(double kontostandNeu = 0.00,unsigned long bankleitzahlNeu = 669503499) : // : leitet die initializer list ein
     kontostand(kontostandNeu), //schreibt den Werten von kontostandNeu in das Attribut "kontostand"
     bankleitzahl(bankleitzahlNeu) //schreibt den Werten von bankleitzahlNeu in das Attribut "bankleitzahl"
{
}

Quote:

Originally Posted by Hg(CNO)2 Ist es wichtig, die Paramater einen abweichenden Namen zu geben? Ich will ja, wenn der das Konto anlegt, dass die Bankleitzahl und der Anfangsbestand von 0.00 € in die Datenelemente "Bankleitzahl und Kontostand" gespeichert wird. Der Konstruktor wird ja nur einmal und zwar beim erzeugen des Objekts ausgeführt. Dann kann ich statt bankleitzahlNeu auch nur bankleitzahl benutzen. Oder kollidiert es?

Quote:

innerhalb des Konstruktors nurmehr mit this->bankleitzahl

EineKlasse::EineKlasse()
: m_eineVariable(0)
{
}

Quote:

Originally Posted by MrSm!th und auch in irgendeinem C++ Artikel hab ich mal davon gelesen, dass davon abgeraten wird.

Quote:

Originally Posted by MrSm!th Btw. deine Beispiele setzen das Little Endian Format voraus, dementsprechend sind sie nicht plattformunabhängig.

Quote:

Originally Posted by Hg(CNO)2 Ich denke der Ansatz ist jetzt vorhanden. Auf was bezog sich das hier:

Quote:

Originally Posted by Hg(CNO)2 Die Lösung auf was o.ô?

Quote:

Originally Posted by Hg(CNO)2 Das sie, wie Mr. Smith geschrieben hat, nicht mehr plattformunabhängig sind?

Quote:

Originally Posted by Hg(CNO)2 Ich weiß nicht, wie ich das interpretieren soll.

Quote:

Originally Posted by Hg(CNO)2 Unsigned Short ist ein Datentyp mit einer Größe von: 2 Bytes. Statt des obrigen Datentyps nehme ich int: 4 Bytes. Wird es als 4 Bytes ausgewertet oder weiterhin als 2 Bytes (Low-Highbyte)?

Quote:

Originally Posted by Hg(CNO)2 Wenn ich nun auf den Wert 0xAAFF zugreifen möchte, kann ich einzelnd auf 0xAA oder 0xFF zugreifen und davor ist es nicht möglich oder wie?

	unsigned short foo = 0xFFAA;
	unsigned short low = foo & 0xff;
	unsigned short high = foo >> 8;

Quote:

Originally Posted by Hg(CNO)2 Das es was zu bemängeln gibt wusste ich von vorne rein, aber das lässt sich bei nie vermeiden. Ich denke das liegt daran, dass ich ständig nur lese und weniger Übungen mache...

Quote:

Originally Posted by Hg(CNO)2 Zum wesentlichen this und"m"-Prefix das hatte ich noch nicht. Ich werds mir aber merken.

Quote:

Originally Posted by Hg(CNO)2 Ist es wichtig, die Paramater einen abweichenden Namen zu geben? Ich will ja, wenn der das Konto anlegt, dass die Bankleitzahl und der Anfangsbestand von 0.00 € in die Datenelemente "Bankleitzahl und Kontostand" gespeichert wird. Der Konstruktor wird ja nur einmal und zwar beim erzeugen des Objekts ausgeführt. Dann kann ich statt bankleitzahlNeu auch nur bankleitzahl benutzen. Oder kollidiert es?