bin bzgl folgndem Code

using namespace std;

int main()
{
  int* a = new int(1);

  shared_ptr<int>(a);

  cout << *a << endl;

  return 0;
}

und allgemien bzgl. der Erstellung von anonymen std::shared_ptr Objekten verwirrt.
Warum bekomme ich im obigen Code einen Namenskonflikt bzgl "a"?

So wie ich das sehe wird zunächst ein Pointer a deklariert und initialisiert mit dem Wert "1".
Anschließend wird ein anonymes std::shared_ptr Objekt instanziiert, welches den Pointer "a" kapseln soll.

Das scheint aber nicht richtig zu sein, kann da evtl einer von euch Klarheit schaffen?

Gruß

#include <memory>
using namespace std;

int main()
{
  int* (a) = new int(1);//beachte die gleichen Klammern

  shared_ptr<int>(a);

  cout << *a << endl;

  return 0;
}

#include <memory>
#include <iostream>
using namespace std;

int main()
{
  int* a = new int(1);

  (void)shared_ptr<int>(a);//Zum Ausdruck gemacht, höhö!

  cout << *a << endl;

  return 0;
}

Angenommen man hat so etwas

void inc(std::shared_ptr<int> x)
{
  ++(*x);
}

int main()
{
  int* a = new int(1);  

  inc(std::shared_ptr<int>(a));

  std::cout << *a << std::endl;

  return 0;
}

d.h. man hat ne Funktion "inc" die einen shared_ptr<int> erwartet und den gekapselten wert Inkrementiert.
Hat man nun nur einen "normalen" Pointer wie in Zeile 8 vorliegen und will diesen auch irgendwie an "inc" übergeben, dann wollte ich das so versuchen wie in Zeile 10, das scheint aber nicht zu klappen.
Habt ihr eine Idee wie man so etwas macht?

Gruß

inc(std::shared_ptr<int>(a));

Hast du das mal probiert zu kompillieren? Das ist so erlaubt und deklariert keine Variable a.

volkard schrieb:

(void)shared_ptr<int>(a);//Zum Ausdruck gemacht, höhö!

Es gibt auch noch andere Workarounds:

(shared_ptr<int>(a)); // Zum Ausdruck gemacht, hähä!
  shared_ptr<int>{a}; // Zum Ausdruck gemacht (C++11-Style), hehe!

Wer std::shared_ptr verwendest, verwendet auch C++11, daher würde ich die letztere Variante bevorzugen.

Btw @MatheStein, ich hoffe du bist dir bewusst, dass dein cout so nicht hingehört?

int* a = new int(1); // Speicher anfordern
  shared_ptr<int>{a};  // Speicher ownen und freigegeben
  cout << *a << endl;  // Kabumm!

Btw @MatheStein, ich hoffe du bist dir bewusst, dass dein cout so nicht hingehört?

int* a = new int(1); // Speicher anfordern
  shared_ptr<int>{a};  // Speicher ownen und freigegeben
  cout << *a << endl;  // Kabumm!

Das weiß er und das IST das Problem.
Er hat ein Objekt in einem normalen Zeiger. Will auch nicht da einen shared_ptr verwenden.
Doch eine fremde Funktion will einen shared_ptr übergeben bekommen.
Und ruft er sie auf, kracht es später.
Wie am geschicktesten es lösen?

wtfvonabisz schrieb:

...

Das weiß er und das IST das Problem.
Er hat ein Objekt in einem normalen Zeiger. Will auch nicht da einen shared_ptr verwenden.

Nee, DAS ist das Problem. Er hat einen besitzenden, nicht-smarten Pointer. Das ist kein guter Stil. Er will sich jetzt einen abbrechen, um um Smartpointer herumzukommen. Das ist schlechter Stil, um schlechten Stil beibehalten zu können. Warum das Ganze??

int main()
{
  auto a = make_shared<int(1);  

  inc(a);

  std::cout << *a << std::endl;
}

Fertig ist die Laube.

std::shared_ptr</* EINE KLASSE */>(this)

benötigt

Gruß

Das Problem ist/war, dass ich in einem Objekt meinen this-Zeiger als shared_ptr übergeben musste, habe also so etwas wie

std::shared_ptr</* EINE KLASSE */>(this)

benötigt

Gruß

Du willst allen ernstes deine Klasse, egal ob sie vom Heap allokiert wurde oder nicht, einem shared_ptr übergeben?

Vielleicht liegt auch das Problem, dass die Funktion einen shared_ptr verlangt, ohne das sie es muss bzw. rechtfertigt. DAS ist schlechter Stil, aber es ist ja Mode jeden beknackten Zeiger in Smartpointer zu wickeln. Tut nicht Not. Soll so auch nicht gemacht werden. (Siehe Herb Sutter).

Jo, könnte gut sein.

Und pumuckl hat mich traurig gemacht.