folgender Code wird von g++ 3.x einwandfrei kompiliert:

template <class Type> class Foo
{
        private:
                Type m_t;

                Foo( const Foo& ); // Zeile 6
        public:
                explicit Foo( const Type& t )
                 : m_t(t)
                {
                }

                operator Type() const
                {
                        return m_t;
                }
};

template <class A> bool set( const A& value )
{
        return true;
}

int main()
{
        int i = 5;
        Foo<int> foo(i);

        set( Foo<int>( (int)foo ) ); // Zeile 30
}

g++ 4.0 hingegen sagt:

bla.cc: In function 'int main()':
bla.cc:6: error: 'Foo<Type>::Foo(const Foo<Type>&) [with Type = int]' is private
bla.cc:30: error: within this context

Ist nun der g++ kaputt oder der Code?
Kennt jemand einen Workaround außer eine lokale Variable zu definieren
und diese dann der set Funktion als Parameter zu übergeben?

Temporaries of class type are created in various contexts: binding an rvalue to a reference (8.5.3), returning an rvalue (6.6.3), a conversion that creates an rvalue (4.1, 5.2.9, 5.2.11, 5.4), throwing an exception (15.1), entering a handler (15.3), and in some initializations (8.5). [Note: the lifetime of exception objects is described in 15.1. ] Even when the creation of the temporary object is avoided (12.8), all the semantic restrictions must be respected as if the temporary object was created. [Example: even if the copy constructor is not called, all the semantic restrictions, such as accessibility (clause 11), shall be satisfied. ]
2 [Example:

class X {
// ...
public:
// ...
  X(int);
  X(const X&);
  ~X();
};

X f(X);

void g()
{
  X a(1);
  X b = f(X(2));
  a = f(a);
}

Here, an implementation might use a temporary in which to construct X(2) before passing it to f() using X’s copyconstructor;
alternatively, X(2) might be constructed in the space used to hold the argument.
Also, a temporary might be used to hold the result of f(X(2)) before copying it to b using X’s copyconstructor;
alternatively, f()’s result might be constructed in b. On the other hand, the expression a=f(a) requires a temporary for either the argument a or the result of f(a) to avoid undesired aliasing of a]

eigentlich müsste der code einwandfrei funktionieren und auch mein vc++6 schluckt ihn ohne zu murren *seltsam*

folgender Code wird von g++ 3.x einwandfrei kompiliert:

Kann ich nicht bestätigen, zumindest beim 3.4.4.

Konfusius schrieb:

eigentlich müsste der code einwandfrei funktionieren und auch mein vc++6 schluckt ihn ohne zu murren *seltsam*

Nicht raten, nachschlagen...

ign0rant schrieb:

Kennt jemand einen Workaround außer eine lokale Variable zu definieren

Nunja, da dein Code keinen Sinn ergibt, kann ich dazu nicht viel sagen. Vielleicht könntest du mal ein reelles Szenario als Beispielcode posten.

Konfusius schrieb:

eigentlich müsste der code einwandfrei funktionieren und auch mein vc++6 schluckt ihn ohne zu murren *seltsam*

Nicht raten, nachschlagen...

nicht raten? ich dachte, es wäre mal ein perfekt getarnter witz