Unterscheidung des Compilers

[Raptor]

Gegeb sei eine Klasse foo.

Wenn ich nun eine Intanz dieser Klasse deklarieren moechte,
dann mache ich das wie folgt, vorrausgesetzt der Konstruktor benoetigt 3 Argumente

Variable

foo variable(a,b,c);

Bei einer Funktion hingegen kann ich beliebig viele Parameter angeben, obwohl der Konstruktor nur 3 akzeptiert.

Prototyp einer Funktion

foo function(int a,int b,int c,int d, /*char e, float f, .....*/)

Da ja bei beiden ein Objekt der Klasse foo erzeugt wird, frage ich mich, wie kann der Compiler zwischen Variable und Funktion unterscheiden.
denn bei der Funktion kann ich beliebig viele Parameter angeben beliebigen Typs und bei der Variable nur das, was im Konstruktor steht.

#include <iostream>
using namespace std;

class foo
{
private:
     int a,b;
public:
     foo(int one=5, int two=4){a=one;b=two;}//Konstruktor akzeptiert 2 Argumente
};

foo funktion(long double a, char x,float g=3,char ch=' ', long fr=4) //beliebig viele
{
	foo newInstanz;
	return newInstanz;
}

int main()
{

	long double lo=6.4444444444;
	char ch='f';
	float fl=4.5;
	char g='e';
	long fr=3;

	foo variable(lo,ch); //nur 2

	funktion(lo,ch,fl,g,fr); //beliebig viele
	return 0;
}

Wie kann der Compiler zwischen Funktionen und Variable unterscheiden?

(Falls ich an manchen Stellen Muell geschrieben haben sollte, bitte ich darum geschlagen zu werden :))

MfG

Raptor

[SirLant]

Ganz einfach:

foo neuesFoo (1, 2); // neues Objekt erzeugen
neuesFoo.funktion (1.0, 'b'); // funktion aufrufen

Ich denke du hast da etwas falsch verstanden, die Funktionen kannst du nur über ein
existierendes Objekt aufrufen.

Bin mir aber nicht sicher, ob du das wissen wolltest, ist es das was du wissen wolltest?

[Raptor]

Nein, ich meine schon eine einfache Funktion und keine Methode der Klasse.
Eine Funktion also, mit dem Return-Wert des Typs foo.

[elise]

foo variable(lo,ch); //nur 2

    funktion(lo,ch,fl,g,fr); //beliebig viele

das erste ist eine instanzierung eines objektes, sprich: der konstruktor wird aufgerufen.
das zweite ist eine globale funktion. nicht mehr und nicht weniger.

wo ist das problem? das eine hat mit dem anderen nix zu tun.

das du in der globalen funktion wieder ein objekt instanzierst, und per value zurückgibst, sei dir freigestellt.

[Raptor]

Aber dann wuerde ja bei einer Funktion mit dem Rueckgabewert foo
gar keine Instanz angelegt. So wurde es mir hier auf dem Board aber gesagt.

[elise]

da ist doch eine instanz, es werden sogar zwei instanzen angelegt
die eine in der funktion, danach eine für den rückgabewert, und die in der funktion wird nach rückkehr der funktion wieder zerstört.
erhalten bleibt die des rückgabewertes, mit der kannst du in der main weiterarbeiten.

so long

[SirLant]

Achso, die "funktion" steht ja gar nicht in der Klasse, hab ich mich verlesen.

Also, wenn du sowas schreibst 'foo neuesFoo ();', dann versteht der Compiler es
als Funktionsdeklaration, aber sonst kann er das ganz gut auseinanderhalten.

Bei deiner Funktion wird ein "foo" erzeugt im return, nur wird es gleich wieder
verworfen da es nicht verwendet wird.

[Raptor]

aber wenn bei der funktion eine instanz angelegt wird, dann
wird sie ja, genau wie die variable, vom konstruktor initialisiert.

Und bei der Funktion sind es beliebig viele Argumente, bei der Variablen nur so viele wie im Konnstruktor

[SirLant]

Raptor schrieb:

aber wenn bei der funktion eine instanz angelegt wird, dann
wird sie ja, genau wie die variable, vom konstruktor initialisiert.

Und bei der Funktion sind es beliebig viele Argumente, bei der Variablen nur so viele wie im Konnstruktor

Nein, das Objekt, kann über den copy-ctor initialisiert werden, welcher
genau ein 'foo' als Parameter erwartet.

Die Funktion nimmt nur so viele Argumente wie du in der Parameterliste angibst.

[elise]

in der funktionsdefinition instanzierst du mit standardwerten (schau mal in deine klasse )
beim rückgeben wird der kopierkonstruktor (compilergeneriert, deswegen siehst du ihn nicht) angewendet... lies mal dazu nach.