"explicit" für parameter

[peterchen]

gibt es eine art "explicit" für parameter, um automatische Konvertierungen für einen parameter zu unterdrücken? Kann man da was basteln?

[HumeSikkins]

Hallo,
du meinst ein kontext-abhängiges Konvertierungsverbot?
Nach dem Motto: Ein Bar ist automatisch konvertierbar nach Foo, es sei denn Foo ist ein Paramter für die Funktion f.
Direkt gibt es sowas natürlich nicht.
Du kannst das selbe aber über einen Trick erreichen:

class Bar
{};

class Foo
{
public:
    Foo();
    // Ein Bar ist konvertierbar in ein Foo
    Foo(Bar b);
};

template <class T>
struct Explicit
{
    Explicit(const T& t)
        : t_(t)
    {}
    const T& t_;
};
void func(const Foo& f);
void gunc(const Explicit<Foo>& f):
int main()
{
    Foo f;
    func(f);  // OK
    gunc(f);  // OK Foo -> Explicit<Foo>

    Bar b;
    func(b);  // OK Bar -> Foo
    gunc(b);  // Error! Keine Konvertierung möglich
}

[peterchen]

Sowas ähnliches hab' ich auch schon probiert, aber da bekomm' ich probleme mit dem automatischen erkennen von template-parametern

(wenn ich hab:

template <class T>
void gunc(Explicit<T> value)

Mein ursprüngliches Problem hab' ich jetzt anders gelöst aber trotzdem danke

[peterchen]

ich glaub, ich hatte da noch blödsinn drin... muß ich mir heut abend nochmal in ruhe angucken.

sorry