bin gerade fleißig am C++ lernen. Da bin ich auf ein kleines Problm gestoßen: Ich habe im Moment eine Klasse, derren Konstruktor sich wie folgt deklariert:

ort(int neuX = 0, int neuY = 0) : X(neuX), Y(neuY) {
                }

Wenn ich nun ein Objekt wie folgt erzeuge:

ort nOertchen(23);

, funktioniert alles wunderbar. Aber, bei solch einem Objekt

ort nOertchen();

zeigt der Compiler bei Benutzung eine Fehlermeldung an.

anzeigen(nOertchen);

Fehlermeldung:
main.cpp:11: error: invalid conversion from `ort (*)()' to `int'
main.cpp:11: error: initializing argument 1 of `ort::ort(int, int)'

Gibt es eine Erklärung? Kompletter Code im Anhang.

Mfg
rollinkarl

main.cpp:

#include"ort.h"
#include<iostream>
#include<cstdlib>

using namespace std;

int main() {
    ort nOertchen(23);
    ort nochNOertchen(0);
    anzeigen(nOertchen);
    anzeigen(nochNOertchen);
    cout << entfernung(nOertchen, nochNOertchen) << endl;
    nOertchen.aendern(2, 3);
    nochNOertchen.aendern(3,23);
    anzeigen(nOertchen);
    anzeigen(nochNOertchen);
    cout << entfernung(nOertchen, nochNOertchen) << endl;
    nOertchen.aendern(34,57);
    anzeigen(nOertchen);
    anzeigen(nochNOertchen);
    cout << entfernung(nOertchen, nochNOertchen) << endl;

    system("pause");
}

ort.h:

#ifndef ORT_H
#define ORT_H ORT_H
#include<iostream>
#include<cmath>

class ort {
    public:
        int ausgabeX() const;
        int ausgabeY() const;
        void aendern(int neuX, int neuY);
        ort(int neuX = 0, int neuY = 0) : X(neuX), Y(neuY) {
                }
    private:
        int X, Y;
};

inline int ort::ausgabeX() const {
    return X;
}

inline int ort::ausgabeY() const {
    return Y;
}

inline void ort::aendern(int neuX, int neuY) {
    X = neuX;
    Y = neuY; 
}
inline double entfernung (const ort& ort1, const ort& ort2) {
       double ex = static_cast<double> (ort1.ausgabeX() - ort2.ausgabeX());
       double ey = static_cast<double> (ort1.ausgabeY() - ort2.ausgabeY());
       return std::sqrt(ex*ex + ey*ey);
       }

inline void anzeigen (const ort& o) {
       std::cout << "(" << o.ausgabeX() << "|" << o.ausgabeY() << ")" << std::endl;
       }
#endif

ort.cpp leer

Fehlermeldung:
main.cpp:11: error: invalid conversion from `ort (*)()' to `int'
main.cpp:11: error: initializing argument 1 of `ort::ort(int, int)'

Gibt es eine Erklärung? Kompletter Code im Anhang.

Ich habe mir den Code nicht im Detail angeschaut, nur mal bei mir durch den Compiler (Visual C++ 2008, SP1; Mit Warnstufe 4) gejagt: Kein Fehler gemeldet

Auf Anhieb sehe ich hier auch keinen Fehler.

Welchen Compiler verwendest du?

Wenn ich nun ein Objekt wie folgt erzeuge:

ort nOertchen(23);

, funktioniert alles wunderbar. Aber, bei solch einem Objekt

ort nOertchen();

zeigt der Compiler bei Benutzung eine Fehlermeldung an.

anzeigen(nOertchen);

Fehlermeldung:
main.cpp:11: error: invalid conversion from `ort (*)()' to `int'
main.cpp:11: error: initializing argument 1 of `ort::ort(int, int)'

Gibt es eine Erklärung?

Für den Compiler sieht " ort nOertchen(); " aus wie eine Funktionsdeklaration (mit Namen "nOertchen", ohne Parameter und mit Rückgabewert vom Typ "ort"). Um den Konstruktor ohne Argumente aufzurufen, mußt du die Klammern weglassen, also:

ort nOertchen;

Und ja, das ist irgendwie komisch und verwirrend, läßt sich aber leider nichts dran ändern.

Was sagt eigentlich der Standard dazu? Und wieso sucht der Compiler in einer Funktion nach Funktionsdeklarationen

Ich kann jetzt nicht die passende Stelle im Standard zitieren, wäre interessant, wenn jemand dazu noch genaueres weiß.
Aber meines Wissens sind Deklarationen auch innerhalb von Funktionen erlaubt (und dann auch nur dort sichtbar). Folgendes z.B. funktioniert:

int main()
{
    void foo();
    foo();
}

void foo() { }

Aber meines Wissens sind Deklarationen auch innerhalb von Funktionen erlaubt

Ok, danke, das würde das natürlich erklären

Es ist in meinem C++-Buch auch etwas schwammig formuliert: Dort steht nur für Standardkonstruktoren explizit, dass man die Klammer weglassen muss. Mit ein bisschen Gehirnschmalz hätte ich aber selber darauf kommen könne.

@asc: Mein Compiler ist übrigens MinGW/g++. Das es ohne Fehler durchläuft liegt daran, dass dem Konstruktoraufruf im angehangenen Source Code ein Parameter übergeben wird.

MfG rollinkarl

Funktionsdeklarationen in Funktionen sind allerdings tatsächlich erlaubt.

Da gibt es auch noch viel gemeinere Konstellationen, bei denen es nicht so offensichtlich ist