Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais
Cette documentation est archivée et n’est pas conservée.

make_shared (<memory>)

Crée et retourne shared_ptr qui indique les objets alloués qui sont construits de zéro ou plusieurs arguments à l'aide de l'allocateur par défaut.

template<class Type, class... Types>
    shared_ptr<Type> make_shared(
        Types&&... _Args
    );

Paramètre

Description

_Args

Arguments de constructeur. La fonction déduit les surcharges de constructeur à appeler selon les arguments fournis.

Retourne shared_ptr qui indique l'objet alloué.

La fonction crée l'objet shared_ptr<Type>, un pointeur vers Type(_Args...) comme alloué et construit par l'allocateur par défaut allocator(). L'exemple suivant montre comment créer des pointeurs partagés à un type en appelant les surcharges spécifiques de constructeur.


#include <iostream>
#include <string>
#include <memory>

using namespace std;

class Zebra
{
private:
	int nStripes;
	string name;
public:
	Zebra() : nStripes(-1), name("Default")
	{
		cout << "I'm a default Zebra." << endl;
	}

	Zebra(int i, string s) : nStripes(i), name(s)
	{
		
		std::cout << "My name is " << name 
				  << " and I have " << nStripes 
				  << " stripes." << endl;
	}

	virtual ~Zebra()
	{
		cout << "Goodbye from " << name << endl;


	}

};

void MakeZebras()
{
	auto pzeb = make_shared<Zebra>();
	auto pGeorge = make_shared<Zebra>(5, "George");
}



class SongBase
{
    protected:
     std::wstring id;
     public:
     SongBase() : id(L"Default"){}
      SongBase(std::wstring init) : id(init) {}
      virtual ~SongBase(){}
};
class Song : public SongBase
{
    public:
    std::wstring title_;
    std::wstring artist_;
    std::wstring duration_;
    std::wstring format_;
    //Song(std::wstring title, std::wstring artist) : title_(title), artist_(artist){}
    Song(std::wstring title, std::wstring artist) : title_(title), artist_(artist){}
    //Song(Song&& other)
    //{
    //    title_ = other.title_;
    //    artist_ = other.artist_;
    //    duration_ = other.duration_;
    //    format_ = other.format_;

    //    /*other.title_ = nullptr;
    //    other.artist_ = nullptr;
    //    other.duration_ = nullptr;
    //    other.format_ = nullptr;*/
    //}
    ~Song() 
    {
        std::wcout << L"Deleting " << title_ << L":" << artist_ << std::endl; 
    }

    Song& operator=(Song&& other)
    {
        if(this != &other)
        {
            this->artist_ = other.artist_;
            this->title_ = other.title_;
            this->duration_ = other.duration_;
            this->format_ = other.format_;

            other.artist_ = nullptr;
            other.title_ = nullptr;
            other.duration_ = nullptr;
            other.format_ = nullptr;            
        }
        return *this;
    }

    bool operator ==(const Song& other)
    {
        return this->artist_.compare(other.artist_) == 0  && 
                this->title_.compare(other.title_) == 0;
    }


};

shared_ptr<Song> MakeSongPtr(wstring artist, wstring title)
{
    Song* s = new Song(artist, title);
    shared_ptr<Song> p(s);
    //return make_shared<Song>(artist,title);
    return p;
}



En-tête : <memory>

l'espace de noms: std

Afficher: