C++Talk.NET

Olaf Krzikalla · Guest

Hi,

ich compiliere momentan eine ganze Menge älteren Code durch gcc 3.3.1.
Dass dabei natürlich einige Dinge angemeckert werden, ist klar. Einige
Sachen jedoch verwirren mich zutiefst:

class foo
{
explizit foo (int i) {}
foo (int i, int j) {}
void bar () const;
}

void baz()
{
foo (1).bar();
}

gcc will hier unbedingt folgende Klammern sehen:

void baz()
{
(foo (1)).bar();
}

Diese Schreibweise hab ich noch nirgendwo sonst gesehen.
Ein zweites Problem hatte ich in Zusammenhang mit dem üblichen
Deklaration-statt-Variablendefinition:

class foo2
{
explizit foo2 (const foo&) {}
void bar () const;
}

void baz2()
{
foo2 (foo (1, 2)).bar();
}

Diesen Ausdruck habe ich überhaupt nicht compiliert gekriegt. Erwartet
hätte ich, dass

void baz2()
{
(foo2 ((foo (1, 2)))).bar();
}

korrekt wäre. Nix da. Hier mußte ich schließlich eine nichttemporäre
foo-Variable anlegen.
Das dritte Problem ist etwas komplizierter:

template<class T>
struct temp;

template<class T>
struct fnresult : private T
{
operator temp<T>() {};
};

struct poly
{
poly& operator = (const temp<poly>& p);
fnresult<poly> calc_poly();
};

void f_poly()
{
poly p, q;
q = p.calc_poly();
}

Hier beschwert sich gcc über Access-Probleme. Klar, er versucht, den
compilergenerierten poly::operator= anzuwenden und kann das nur durch
Verletzung der private-Klausel erreichen. Den zweiten Weg über die
Konvertierung nach temp<poly> sieht er nicht oder ignoriert sie. Da
private-Ableitungen ja aber eigentlich auch dazu da sind,
Konvertierungen zu unterbinden, fühle ich mich hier im Recht (und
zumindest Borland stimmt mir in allen neueren Compilervarianten zu).
Welche dieser Probleme sind denn nun gcc-gemacht und welche beruhen auf
meiner ungenügenden Standardkenntnis?

MfG
Olaf Krzikalla

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de