[C++] Standardkonstruktor wird nicht ausgeführt

[sscherma]

Hallo,

meine Frage ist kein wirkliches Problem, sondern dient eher zu meinem Verständnis.

Ich habe also ein Klassentemplate. Ein mal der Header mit der Klassendeklaration und die .cpp Datei für die Klassendefinitionen.

Instantiiere ich diese Klasse in meiner main() Funktion mit Parametern, wird ohne Probleme eine Instanz erstellt. Instantiiere ich ohne Parameter, wird der Standardkonstruktor gar nicht erst angesteuert. Ich verstehe nicht wieso das so ist.

Hier der betreffende Teil meines Codes:

(Ich habe den Code so abgeändert, das es nur noch den leeren Standardkonstruktor gibt. )

//Punkt.h

#pragma once

template <typename T>
class Punkt
{
protected:
	struct koordinaten {T x; T y;} *_position;
public:
	//Punkt(void);

	Punkt(void)
	{
	
	//_position = new koordinaten();
	/*setPosX(0);
	setPosY(0);*/
	}

	/*Punkt(T,T);
	Punkt(static Punkt<T>&);*/
	//~Punkt(void);

	T getPosX() {return _position->x;};
	T getPosY() {return _position->y;};
	void setPosX(T x) {_position->x=x;};
	void setPosY(T y) {_position->y=y;};
	
	T Betrag(Punkt<T>);
	T Abstand_z_Nullpunkt(Punkt<T>);

	void Druck();
	void Verschieben(T,T);


	bool operator < (Punkt<T>);
	Punkt<T> operator + (Punkt<T>);
	void operator = (Punkt<T>);
	Punkt<T> operator - ();
};

//Punkt.cpp

#pragma once

#include "Punkt.h"
#include <iostream>
#include <math.h>


//template <typename T>
//Punkt<T>::Punkt(void)
//{
//	_position = new koordinaten();
//	/*setPosX(0);
//	setPosY(0);*/
//}

//template <typename T>
//Punkt<T>::Punkt(static Punkt<T>& punkt)
//{
//	_position = new koordinaten();
//	_position->x = punkt.getPosX();
//	_position->y = punkt.getPosY();
//}
//
//template <typename T>
//Punkt<T>::Punkt(T x , T y)
//{
//	_position = new koordinaten();
//	setPosX(x);
//	setPosY(y);
//}

//template <typename T>
//Punkt<T>::~Punkt(void)
//{
//	delete _position;
//}

template <typename T>
void Punkt<T>::Druck()
{ std::cout << "Der Punkt befindet sich auf den Koordinaten <x:" << getPosX() << " y:" << getPosY() << ">\n";}

template <typename T>
T Punkt<T>::Betrag(Punkt<T> punkt)
{
	return sqrt((double)(punkt.getPosX() + punkt.getPosX()));
}

template <typename T>
T Abstand_z_Nullpunkt(Punkt<T> punkt)
{
	return Betrag<T>(punkt);
}

template <typename T>
void Punkt<T>::Verschieben(T x , T y)
{
	std::cout << "Der Punkt wurde von <x:" << getPosX() << " y:" << getPosY() << "> auf <x:";
	setPosX(x);
	setPosY(y);
	std::cout << getPosX() << " y:" << getPosY() << "> verschoben\n";
}

template <typename T>
bool Punkt<T>::operator < (Punkt<T> operand)
{
	
	if(Betrag((*this)) < Betrag(operand))
		return true;
	else
		return false;
}

template <typename T>
Punkt<T> Punkt<T>::operator + (Punkt<T> operand)
{
	return Punkt<T>((this->getPosX()+operand.getPosX()),(this->getPosY()+operand.getPosY()));
}

template <typename T>
void Punkt<T>::operator = (Punkt<T> operand)
{
	this->setPosX(operand.getPosX());
	this->setPosY(operand.getPosY());
}

template <typename T>
Punkt<T> Punkt<T>::operator - ()
{
	return Punkt<T>(-getPosX(),-getPosY());
}

//Start.cpp

#include <iostream>

#include "Punkt.h"
#include "Punkt.cpp"
#include "Kreis.h"
#include "Kreis.cpp"

using namespace std;

int main ()
{
	/*Punkt<double> punkt1(1,1);
	Punkt<double> punkt2(2,5);
	Punkt<double> punkt3(0,0);*/

	Punkt<double> punkt();


	Kreis<double> kreis();

	
	//Kreis<double> kreis2(1,punkt2);
	
	/*punkt3=punkt1 + punkt2;

	punkt3.Druck();

	punkt3.Verschieben(4,7);*/


	std::system("pause");
	return 0;
}

Nach meinem Verständnis wäre es doch so das beim Aufruf von Punkt<double> punkt(); in der Start.cpp der Standardkonstruktor von Punkt<T> aufgerufen wird und die Instanz erstellt wird, auch wenn keine Variablen oä. initialisiert wurden. Aber ob ich nun Speicher im Standardkonstruktor reserviere oder nicht, er wird einfach übergangen.

Wie soll ich dieses Verhalten verstehen?


Gruß

Ich

[Jodocus_]

Du legst deinen armen C++-Compiler rein. Wie soll er denn bei dem Ausdruck

Punkt<double> punkt();

Zwischen "Erstelle ein Objekt punkt mit dem Standardkonstruktor aus der Templateinstanziierung Punkt<double>" und "Deklariere eine Funktion punkt() mit Rückgabetyp Punkt<double>" unterscheiden? Deshalb ist es C++-Syntax, keine Klammern bei einer Variablendefinition zu benutzen, wenn der Standardkonstruktor aufgerufen werden soll.

Aber hier ist noch einiges im Argen...

#include "Punkt.h"
#include "Punkt.cpp"
#include "Kreis.h"
#include "Kreis.cpp"

Man inkludiert keine C++-Implementierungen von Klassen oder Funktionen, sondern nur ihre Definitionen/Deklarationen. Weißt du überhaupt, was eine Übersetzungseinheit ist? Kennst du die One-Definition-Rule? Weißt du überhaupt was ein Linker ist und was er im Zusammenhang mit C++ tut? Nichts für ungut, aber ich würde dir ehrlich ein gutes Standardwerk nahelegen, weil du momentan sehr viele Basisfehler machst, die man eigenetlich von Anfang an richtig lernen sollte.

[sscherma]

NATÜRLICH, ich würde mich am liebsten selbst in den Arsch treten.

#include "Punkt.h"
#include "Punkt.cpp"
#include "Kreis.h"
#include "Kreis.cpp"

Das kann ich erklären:

Laut http://www.codeproject.com/Articles/...h-file-and-imp unter Methode 2 ist es so möglich Templateklassen im Header zu deklarieren und im Source File zu definieren.

Ich bin natürlich offen für bessere Methoden. Irgendwie muss ich ja dem Linker klar machen wo die Definitionen sind.

[Jodocus_]

Puh, ich hab schon 'nen Schreck gekriegt. Dann nenn die Datei nicht *.cpp, weil das wirklich eine Endung für eine eigene Übersetzungseinheit sein sollte. Gängig wären *.h, *.hxx, *.hpp, *.impl und mein Favorit *.inl.
Als nächstet "verbietet" dir der Standard, Variablen mit "_" beginnen zu lassen. Solche Namen sind für die Implementierung der Standardlibrary reserviert. Gängige Konvention ist es aber, private Membervariablen mit einem "_" enden zu lassen.

Call-by-Reference solltest du dir auch mal anschaun.

[sscherma]

Und nochmal Vielen Dank an dich.
Habe die Dateien umbenannt.

Call-by-Reference werde ich mir auf jeden Fall auch anschauen.

Noch einen schönen Tag.

Gruß

Ich