Welchen Grund hat es, dass Operatoren für atomics nicht überladen wurden, sondern dafür freie Funktionen verwendet werden müssen?

Grüße,
PI

Huhu,

Welchen Grund hat es, dass Operatoren für atomics nicht überladen wurden, sondern dafür freie Funktionen verwendet werden müssen?

Grüße,
PI

Verstehe die Frage nicht.

std::atomic<int> i(0);
std::atomic_fetch_add(&i, 42); // warum nicht i += 42;

gibt es doch.

n3290 schrieb:

template <> struct atomic<integral> {
...
operator integral() const volatile noexcept;
operator integral() const noexcept;
...
atomic() noexcept = default;
constexpr atomic(integral) noexcept;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
integral operator=(integral) volatile noexcept;
integral operator=(integral) noexcept;
integral operator++(int) volatile noexcept;
integral operator++(int) noexcept;
integral operator--(int) volatile noexcept;
integral operator--(int) noexcept;
integral operator++() volatile noexcept;
integral operator++() noexcept;
integral operator--() volatile noexcept;
integral operator--() noexcept;
integral operator+=(integral) volatile noexcept;
integral operator+=(integral) noexcept;
integral operator-=(integral) volatile noexcept;
integral operator-=(integral) noexcept;
integral operator&=(integral) volatile noexcept;
integral operator&=(integral) noexcept;
integral operator|=(integral) volatile noexcept;
integral operator|=(integral) noexcept;
integral operator^=(integral) volatile noexcept;
integral operator^=(integral) noexcept;
};

Gibts einen Grund, warum

std::atomic<T> a = t;

nicht funktioniert?

Das kommt davon, wenn man Header liest, und sich wundert, warum man die Operatoren nicht findet. Funktioniert, danke.

Gibts einen Grund, warum

std::atomic<T> a = t;

nicht funktioniert?

Ich würde es bevorzugen, wenn du deine Fragen anders stellst. Ein Warum macht erst Sinn, nachdem 1. eine Beobachtung gemacht wurde, 2. diese Beobachtung mit einer bestimmten Erwartung verglichen wird; ist also der 3. Schritt, falls zwischen 1. und 2. eine Diskrepanz auftritt. Stellst du gleich die Warum-Frage, kann zu 1. und 2. nichts mehr gesagt werden; übrigens ein Grund der jedenfalls bei mir sehr schnell dazu führt, dass ich die Frage ganz ignoriere (sofern das Problem dort zu verorten ist).

Hier liegt vermutlich ein Problem mit 1. vor. Je nachdem, entweder hast du das Ganze mit einem Compiler versucht - dann ist möglicherweise dort die Unterstützung nicht ausreichend. Oder du hast den Standard gelesen, in diesem Fall wohl nicht intensiv genug. Jedenfalls ist die betreffende Überladung (zufällig) bereits in meinem vorherigen Beitrag dabei.

../main.cpp:57:23: error: use of deleted function 'std::atomic<int>::atomic(const std::atomic<int>&)'

std::atomic<int> i = 42;

../main.cpp:57:23: error: use of deleted function 'std::atomic<int>::atomic(const std::atomic<int>&)'

Ja, das ist korrekt.

PS:
Bemueh dich doch ein bisschen. Nur ein bisschen. Ein klitzi kleines bisschen. Nur ganz ganz ganz ganz ganz wenig.

Steht doch eh alles schon in der Fehlermeldung?

Seit wann wird hier denn ein Copy Ctor aufgerufen?!

dot schrieb:

Steht doch eh alles schon in der Fehlermeldung?

Seit wann wird hier denn ein Copy Ctor aufgerufen?!

http://fara.cs.uni-potsdam.de/~kaufmann/?page=GenCppFaqs&faq=copyvsdirect#Answ

Grundlagen

dot schrieb:

Steht doch eh alles schon in der Fehlermeldung?

Seit wann wird hier denn ein Copy Ctor aufgerufen?!

Spätestens seit es einen C++ Standard gibt...

Du hast die Fehlermeldung offenbar nicht gelesen. Tu's bitte nochmal, bevor du versuchst, mich als Depp hinzustellen.

Lies dir den Link durch, da steht die Problematik ganz genau beschrieben. Als Depp hast du dich gerade selbst abgestempelt.

Du hast die Fehlermeldung offenbar nicht gelesen. Tu's bitte nochmal, bevor du versuchst, mich als Depp hinzustellen.

Das hast du schon längst selber getan.
Quelle

Lies dir den Link durch, da steht die Problematik ganz genau beschrieben. Als Depp hast du dich gerade selbst abgestempelt.

Wenn ich einen Link bekomme, bei dem der Titel "Q: Wird für T x = u; der Zuweisungsoperator von T aufgerufen?" lautet, komme ich mir veräppelt vor.

Und im Übrigen steht da auch: "Der C++ Standard erlaubt bei copy-initialization die Eleminierung des temporären Objekts. [...] In diesem Fall wird aus der copy-initialization also eine direct-initialization."

Ich will keinen Copy Ctor aufrufen, ich will den stinknormalen T-Ctor aufrufen. Ist das so schwer zu kapieren?

Eure Art ist wieder mal zum Kotzen. Vielen Dank. Vielen Dank für nichts.

Wenn ich einen Link bekomme, bei dem der Titel "Q: Wird für T x = u; der Zuweisungsoperator von T aufgerufen?" lautet, komme ich mir veräppelt vor.

Na dann lass mich die, für dein Problem, äquivalente Frage formulieren: "Q: Wird bei T x = u; der Copy-Constructor von T aufgerufen?".

314159265358979 schrieb:

Und im Übrigen steht da auch: "Der C++ Standard erlaubt bei copy-initialization die Eleminierung des temporären Objekts.

Ja der Standard erlaubt die Copy-Elision des erzeugten Temporaries und praktisch jeder Compiler wird die auch durchführen. Das ändert aber nichts daran, dass es sich um eine Copy-Initialization handelt, für die der Copy-Constructor verfügbar sein muss.

314159265358979 schrieb:

Ich will keinen Copy Ctor aufrufen, ich will den stinknormalen T-Ctor aufrufen. Ist das so schwer zu kapieren?

Dann ruf den stinknormalen Ctor auf!? Ist das so schwer zu kapieren?

Wenn ich einen Link bekomme, bei dem der Titel "Q: Wird für T x = u; der Zuweisungsoperator von T aufgerufen?" lautet, komme ich mir veräppelt vor.

Wieso?

Du fragst warum dort der CopyCtor aufgerufen wird. Und das steht in dem Artikel. Weil du = verwendet hast, wird der CopyCtor benutzt. Die Erklaerung warum das so ist, steht in dem Artikel.

Ich will keinen Copy Ctor aufrufen, ich will den stinknormalen T-Ctor aufrufen. Ist das so schwer zu kapieren?

Nein. Aber wenn du dich dumm stellst duerfen wir das auch, oder?
Die Loesung wurde ja schon genannt. Natuerlich nicht auf die netteste Art, keine Frage - aber wer dumm fragt, bekommt dumme Antworten.

Dein Problem ist also, dass du = verwendest wo du es nicht verwenden darfst. Mit einer direct-initialization geht es ohne Probleme.

Eure Art ist wieder mal zum Kotzen. Vielen Dank. Vielen Dank für nichts.

Deine Art ist natuerlich viel besser.

Ne, im Ernst. Du hast potential. Aber du wirfst es durch arroganz weg. Das ist schade. arrogant darf man erst sein, wenn man etwas erreicht hat. Du stehst erst am Anfang. Lerne! Das Potential ist da.

Wenn ich einen Link bekomme, bei dem der Titel "Q: Wird für T x = u; der Zuweisungsoperator von T aufgerufen?" lautet, komme ich mir veräppelt vor.

Statt zu erklären, wie toll du doch bist und wir alle deine Intelligenz unterschätzen, solltest du den Link doch vielleicht nochmal lesen.

Der C++ Standard erlaubt bei copy-initialization die Eleminierung des temporären Objekts. Statt also ein temporäres Objekt zu erstellen und dieses zusammen mit dem Copy-Konstruktor zur Erzeugung des neuen Objekts zu verwenden, kann ein Compiler das neue Objekt auch direkt kreieren. In diesem Fall wird aus der copy-initialization also eine direct-initialization. [...]

Wichtig hierbei ist, dass ein Compiler die beschriebene Transformation nur durchführen darf, wenn der nicht transformierte Code ebenfalls legal wäre. Wäre also z.B. der Copy-Konstruktor von Foo private, so müsste sowohl die Initialisierung von f2, als auch die von f3 in einer Fehlermeldung resultieren. Egal ob der Compiler nun den Weg über ein temporäres Objekt geht oder nicht.

Eigene Hervorhebung.