Classe de ponteiro inteligente contado de referência que implementa propriedade compartilhada
Eu tenho um entendimento sólido da maioria das teorias de OO, mas a única coisa que me confunde muito são os destruidores virtuais. Eu pensei que o destruidor sempre é chamado, não importa o que e para cada objeto na cadeia. Quando você pretende torná-los virtuais e por
std::shared_ptr<Object> p1 = std::make_shared<Object>("foo"); std::shared_ptr<Object> p2(new Object("foo")); Muitas postagens do google e do stackoverflow existem sobre isso, mas não consigo entender por que make_sharedé mais eficiente do que usar diretamente shared_ptr. Alguém...
Quando uma função recebe um shared_ptr(de boost ou C ++ 11 STL), você a está passando: por referência const: void foo(const shared_ptr<T>& p) ou por valor void foo(shared_ptr<T> p):? Eu preferiria o primeiro método porque suspeito que seria mais rápido. Mas isso realmente vale a...
Comecei a estudar ponteiros inteligentes do C ++ 11 e não vejo nenhum uso útil de std::weak_ptr. Alguém pode me dizer quando std::weak_ptré útil /
Eu tenho esse código que não funciona, mas acho que a intenção é clara: testmakeshared.cpp #include <memory> class A { public: static ::std::shared_ptr<A> create() { return ::std::make_shared<A>(); } protected: A() {} A(const A &) = delete; const A &operator...
Apenas uma pequena consulta sobre shared_ptr. É uma boa prática usar shared_ptrapontar para uma matriz? Por exemplo, shared_ptr<int> sp(new int[10]); Se não, então por que não? Uma razão pela qual eu já estou ciente é que não é possível aumentar / diminuir o shared_ptr. Portanto, ele não...
Estou tendo problemas para entender o uso de ponteiros inteligentes como membros da classe em C ++ 11. Eu li muito sobre ponteiros inteligentes e acho que entendo como unique_ptre shared_ptr/ weak_ptrtrabalho em geral. O que eu não entendo é o uso real. Parece que todo mundo recomenda usar...
Estive pesquisando o código-fonte do Clang e encontrei este trecho: void CompilerInstance::setInvocation( std::shared_ptr<CompilerInvocation> Value) { Invocation = std::move(Value); } Por que eu iria querer std::moveum std::shared_ptr? Existe algum ponto em transferir a propriedade de um...
Encontrei algum código usando std :: shared_ptr para executar uma limpeza arbitrária no desligamento. No começo, achei que esse código não funcionaria, mas tentei o seguinte: #include <memory> #include <iostream> #include <vector> class test { public: test() { std::cout...
Estou escrevendo um método de acesso para um ponteiro compartilhado em C ++ que funciona mais ou menos assim: class Foo { public: return_type getBar() const { return m_bar; } private: boost::shared_ptr<Bar> m_bar; } Portanto, para oferecer suporte à constância getBar()do tipo de...
Se eu tenho uma função que precisa trabalhar com um shared_ptr, não seria mais eficiente passar uma referência a ela (para evitar a cópia do shared_ptrobjeto)? Quais são os possíveis efeitos colaterais ruins? Eu imagino dois casos possíveis: 1) dentro da função é feita uma cópia do argumento, como...
Estou lendo http://gcc.gnu.org/onlinedocs/libstdc++/manual/shared_ptr.html e alguns problemas de segurança de thread ainda não estão claros para mim: Padrão garante que a contagem de referência seja tratada com segurança de thread e seja independente de plataforma, certo? Problema semelhante - o...
Estou muito frustrado agora, depois de várias horas tentando descobrir onde shared_ptr está localizado. Nenhum dos exemplos que vejo mostra código completo para incluir os cabeçalhos para shared_ptr(e funcionando). Simplesmente afirmando std, tr1e <memory>não está ajudando em nada! Eu baixei...
Atualmente, estou tentando aprender como usar ponteiros inteligentes. No entanto, ao fazer alguns experimentos, descobri a seguinte situação para a qual não consegui encontrar uma solução satisfatória: Imagine que você tenha um objeto da classe A sendo pai de um objeto da classe B (o filho), mas...
A questão cabe mesmo no título: tenho curiosidade de saber qual é a razão técnica para esta diferença, mas também a lógica? std::shared_ptr<void> sharedToVoid; // legal; std::unique_ptr<void> uniqueToVoid; //
A biblioteca padrão do C ++ 11 fornece algum utilitário para converter de a std::shared_ptrpara std::unique_ptrou vice-versa? Esta operação é
Qual é o melhor método para passar a shared_ptrde um tipo derivado para uma função que recebe a shared_ptrde um tipo base? Eu geralmente passo shared_ptrs por referência para evitar uma cópia desnecessária: int foo(const shared_ptr<bar>& ptr); mas isso não funciona se eu tentar fazer...
Se eu declarar um objeto envolvido em um ponteiro compartilhado: std::shared_ptr<myClass> myClassObject(new myClass()); então eu queria passá-lo como um argumento para um método: DoSomething(myClassObject); //the called method void DoSomething(std::shared_ptr<myClass> arg1) {...
Digamos que eu tenha um shared_ptralocador personalizado e um deleter personalizado. Não consigo encontrar nada no padrão que fale sobre onde o deletador deve ser armazenado: não diz que o alocador personalizado será usado para a memória do deletador e não diz que não será. Isso não é...
O código abaixo produz um aviso ao executar com desinfetante de threads no macOS. Não consigo ver onde está a corrida. O bloco de controle shared_ptr e weak_ptr é seguro para threads, e empurrar e saltar do std::queueé feito com um bloqueio mantido. #include <future> #include...