Perfect Forwarding ohne "Templates"

[adasdasdasd]

Hi,

folgende Situation.

class Foo : public std::vector<LargeClass> {
public:
    Foo(std::vector<LargeClass>/*universal reference*/ vec, bool flag) 
        : std::vector<LargeClass>(std::forward(vec)) 
    {
        doSomeWithFlag(flag);        
    }
}

Im Konstruktor bräuchte ich für das perfect forwarding eine universal-reference für den vector. Dafür müsste ich jedoch einen Template Parameter einführen. Gibt es eine Möglichkeit dies zu umgehen? Ich weiß, dass es nur ein std::vector sein kann. Ich würde ungern einen Template Parameter einführen und diesen dann Spezialisieren. Die Alternative wäre natürlich einfach zwei Konstrukoren anzubieten, aber vielleicht lässt es sich ja anders lösen.

[hustbaer]

Es lässt sich (so-gut-wie) immer alles anders lösen.
Die Frage ist aber: wieso willst du es anders lösen? Was für eine Verbesserung erwartest du dir dadurch?
Einfacher wird es dadurch nämlich sicher nicht.

[Columbo]

Wenn du lediglich Kopien vermeiden möchtest, geht

Foo(std::vector<LargeClass> vec, bool flag) 
        : std::vector<LargeClass>(std::move(vec)) 
    { 
        doSomeWithFlag(flag);         
    }

Per Template sähe es so aus

template <typename T, std::enable_if_t<std::is_same<std::decay_t<T>, std::vector<LargeClass>>{}, int> = 0>
    Foo(T&& vec, bool flag) 
        : std::vector<LargeClass>(std::forward<T>(vec)) 
    { 
        doSomeWithFlag(flag);         
    }

[adasdasdasd]

hustbaer schrieb:

Es lässt sich (so-gut-wie) immer alles anders lösen.
Die Frage ist aber: wieso willst du es anders lösen? Was für eine Verbesserung erwartest du dir dadurch?

Danke für die schnelle Antwort. Ich hatte mir erhofft, dass ich etwas simples übersehen habe und es mehr oder weniger wie in meinem Pseudocode aussehen würde.

hustbaer schrieb:

Einfacher wird es dadurch nämlich sicher nicht.

Damit ist alles gesagt!

[adasdasdasd]

Arcoth schrieb:

Wenn du lediglich Kopien vermeiden möchtest, geht

Foo(std::vector<LargeClass> vec, bool flag) 
        : std::vector<LargeClass>(std::move(vec)) 
    { 
        doSomeWithFlag(flag);         
    }

Perfekt, genau soetwas habe ich gemeint!

[sebi707]

Im übrigen ist es nicht so gut von std::vector zu erben weil diese Klasse keinen virtual Destructor hat. Kannst du den vector nicht als Membervariable speichern oder wieso willst du davon erben?

[hustbaer]

Arcoth schrieb:

Wenn du lediglich Kopien vermeiden möchtest, geht

Foo(std::vector<LargeClass> vec, bool flag) 
        : std::vector<LargeClass>(std::move(vec)) 
    { 
        doSomeWithFlag(flag);         
    }

*facepalm* (@self)
Gut, das ist jetzt zwar kein perfect forwarding, aber es ist definitiv einfacher, und genau das was der OP will.
Manchmal kann man schon sehr auf dem Schlauf stehe - bzw. Fragen zu wörtlich nehmen und dann ...

[Jockelx]

adasdasdasd schrieb:

eine universal-reference

OT zur Info:
Das Ding heisst jetzt 'forward reference'

[Columbo]

Forwarding reference.

[Jockelx]

Ach ja, das ist das schöne an Foren: Man will jemanden helfen und lernt dann selber wieder was.
Danke für die Verbesserung.