我想在 lambda 表达式中捕获共享指针。尝试了两种方法：
\n捕获共享指针
\n错误：非静态数据成员 A::ptr 的使用无效
\n创建一个弱指针并捕获它（通过网上的一些结果找到这个）。我不确定我的做法是否正确
\n错误： \xe2\x80\x98const 类 std::weak_ptr\xe2\x80\x99 没有名为 \xe2\x80\x98someFunction\xe2\x80\x99 的成员
\n在有人将其标记为重复之前，我知道它可能与其他一些问题类似，但他们的解决方案似乎都不适合我。想知道我做错了什么以及如何解决它，这就是我来这里的原因。
\n文件.h
\n#include "file2.h"\n\nclass A{\n private:\n uint doSomething();\n std::shared_ptr<file2> ptr;\n}\n文件.cpp
\n#include "file.h"\n\nuint A::doSomething(){\n ...\n\n // Tried using weak pointer\n //std::weak_ptr<Z> Ptr = std::make_shared<Z>();\n \n auto t1 = [ptr](){\n auto value = ptr->someFunction;}\n \n // auto t1 = [Ptr](){\n // auto value = Ptr.someFunction;}\n \n ...\n }\n我有以下代码:
#include <memory>
class Foo;
typedef std::tr1::shared_ptr<Foo> pFoo_t;
class DoSomething
{
public:
static void doSomething( pFoo_t p) { printf( "doing something...\n"); }
static void doSomethingElse( pFoo_t p) { printf( "doing something else...\n"); }
};
class Foo
{
public:
Foo() { printf( "foo()\n"); }
~Foo() { printf( "~foo()\n"); }
public:
void doSomething() { DoSomething::doSomething(pFoo_t(this)); }
void doSomethingElse() { DoSomething::doSomethingElse(pFoo_t(this)); }
};
int _tmain(int argc, _TCHAR* argv[])
{
Foo foo;
foo.doSomething();
foo.doSomethingElse();
return 0;
}
我开始这个样本,然后我得到下一个断言:_BLOCK_TYPE_IS_VALID(pHead-> nBloakUse).
我怎么能避免这个？
我使用以下代码来解决此问题:
class Foo;
typedef …专业人士在那里
这是我第一次向董事会发布问题，这在过去对我有很大帮助。我仍然是编程新手，并且在过去的几个月里一直在尝试学习有关编程和软件开发的很多知识。
我最近解决了“ c ++ 11-Smart Pointers”主题，并决定重写几周前学到的所有设计模式，包括使用shared_ptr和weak_ptr进行资源管理的“观察者模式”。
当我尝试编写观察者模式的简单实现时（例如在Head First的设计模式或E.Gamma的设计模式中），同时为可观察的主题和观察者使用接口类，并且为每个观察者分别使用一个具体的类，我收到了来自Visual Studio的各种错误消息。我只是不了解如何在此模式下组合shared_ptr和weak_ptr，这可能是由于我仍然不完全了解两者的组合。
不幸的是，即使是在Internet上进行彻底的搜索也没有给我提供一个简单的“使用智能指针的观察者模式”示例，它可以为我提供指导。
因此，我想知道，你们中的一个人是否会知道在哪里可以找到这种简单的实现方式，或者愿意为我提供自己的一个。两者都将非常有帮助:-)
非常感谢
编码器
有没有搞错 ？(此后报价后以粗体显示的真实问题)
§20.7.2.2.1
template<class Y> explicit shared_ptr(const weak_ptr<Y>& r);
23要求:Y*应可转换为T*.24效果:构造一个与r共享所有权的shared_ptr对象,并存储r中存储的指针的副本.
25后置条件:use_count() == r.use_count().
26投掷:bad_weak_ptr何时r.expired().
27异常安全:如果抛出异常,则构造函数无效.
这不是助推行为.从过期的弱构造的共享给出一个空的共享.你可以在布尔上下文中测试它.
为什么委员会选择了例外的方式？例如,谷歌C++指南完全取消了异常使用.具有此类指导的项目,甚至在构建时禁用异常(在授权禁用的编译器上)将如何禁用？
最后,如果这可能经常发生(开发人员依赖过期的指针检测作为正常的程序流),那么它(对于实时程序)是不是很危险？我记得有一篇文章提到了实现异常的两种可能的策略,一种是减慢一切,但不是真的在异常发生时,另一种只有在异常发生时才会缓慢,但不会影响其余部分.我想这在某种程度上仍然必须成立.
我需要解释以下行为:
#include <iostream>
#include <memory>
#include <vector>
struct A {
std::string s = "foo";
std::weak_ptr<A> h;
std::shared_ptr<A> && getR() {
return std::move(h.lock());
}
std::shared_ptr<A> getL() {
return h.lock();
}
};
std::vector< std::shared_ptr<A> > storage;
std::vector< std::weak_ptr<A> > accountant;
void store(std::shared_ptr<A> && rr) {
std::cout << "store '" << rr->s << "' uses: " << rr.use_count() << std::endl;
storage.push_back(std::move(rr));
}
int main() {
// create keeper of A
auto keeper = std::make_shared<A>();
keeper->s = "bar";
// store weak_ptr-type handle with accountant …我对智能指针完全是新手，而且从未接触过weak_ptrC++。
我在 class 中有一个函数Y，它接受weak_ptrclass 的参数 a X。
在类的函数内部Y，我需要X通过weak_ptr.
作为参考，这里是一个粗略的类定义：
Y.cpp
class Y {
public : Y();
~Y();
int foo(std::weak_ptr<X> x);
};
X.cpp
class X {
public : std::string func1();
int func2();
};
foo()在类的函数内部Y，我需要能够访问函数func1并func2使用weak_ptr x.
我不知道为什么我需要使用weak_ptr，但这就是我应该实现的。
我无法找到任何使用weak_ptr.
我的问题是：是否存在share_ptr引用计数为0，而weak_ptr引用计数不为0的情况？
C++中make_shared和普通shared_ptr的区别
引用这个线程，显示如果一个shared_ptr是由weak_ptr创建的，make_shared并且有weak_ptr，它的控制块将是活动的，until shared_ptr和weak_ptr的引用计数都为0。它说：
必须有一种方法让weak_ptr 确定托管对象是否仍然有效（例如锁）。他们通过检查拥有托管对象（存储在控制块中）的shared_ptr 数量来做到这一点。结果是控制块一直处于活动状态，直到共享指针计数和弱指针计数都达到 0。
我做了一个快速测试。我希望shared_ptr创建的make_shared，如果有weak_ptr指向它，control block在shared_ptr被破坏后它仍然会保存。
#include<memory>
#include<iostream>
using namespace std;
struct My {
int m_i;
My(int i) : m_i(i) { cout << "My ctor:" << m_i << '\n';}
~My() { cout << "My ctor:" << m_i << '\n';}
};
weak_ptr<My> wp1, wp2;
int main() {
{
auto sp1 = shared_ptr<My>(new My(30));
wp1 = weak_ptr<My>(sp1);
}
cout<< wp1.use_count() << endl;
{
auto sp2 = make_shared<My>(40); …注意：在发布问题之前，我已经浏览了有关std::bad_weak_errorwhile usingshared_from_this将现有实例的 shared_ptr 传递shared_ptr给另一个方法的现有问题。它们都与此类似：
shared_from_this()std::enable_shared_from_this<>public。以下是重现该错误的示例代码：
#include <iostream>
#include <memory>
class ILogger {
public:
virtual ~ILogger() {}
virtual void Log() = 0;
};
class LogManager;
class Logger : public ILogger {
public:
Logger(std::shared_ptr<LogManager> logManager)
: m_logManager(logManager)
{
}
void Log() override
{
std::cout << "Dump logs";
}
private:
std::shared_ptr<LogManager> m_logManager;
};
class ILogManager {
public:
virtual ~ILogManager() {}
virtual std::shared_ptr<ILogger> GetLogger() = 0;
};
class LogManager : public ILogManager, public …我对所有C++编码器都有一个小问题!对于您来说,它是否与"C++哲学"兼容,以重新编码您自己的智能指针.实际上我将shared_ptr与weak_ptr一起用于项目,但它使代码过于复杂.我当然可以使用raw_ptr,但是......它是"普通c"......所以你怎么看待它？我应该重新编写自己的智能指针还是继续将shared_ptr与weak_ptr一起使用
#include <memory>
#include <iostream>
struct Foo {
Foo() { std::cout << "Constructor ...\n"; }
void doSth() {std::cout << "hi" << std::endl;}
~Foo() { std::cout << "Destructor ...\n"; }
};
int main() {
{std::weak_ptr<Foo> jack = (*(new std::shared_ptr<Foo>(new Foo)));
std::cout << (jack).use_count() << std::endl;
// std::shared_ptr<Foo> ptr = jack.lock();
// std::cout << ptr.use_count() << std::endl;
}
}
use_count()返回值为1,因此我认为拥有该对象的最后剩余的shared_ptr将被销毁,因此将调用析构函数.但事实并非如此.任何人都可以解释原因吗？如果我想维护这样的结构:new std :: shared_ptr(new Foo)并且还调用了析构函数,我该怎么办？代码只是为了好玩而编写,没有任何应用程序背景.
首先,一个典型的实施是std::weak_ptr什么？特别是std::weak_ptr只是一个控制块的指针std::shared_ptr？
如果所有std::shared_ptr引用都消失了,内部控制块是否被删除？如果是这样,std::weak_ptr::expired()如果重新使用该内存,如何正常运行？
我有一个包含a的对象,std::weak_ptr我想memcpy将对象转换为稍后要处理的缓冲区.这样做会以某种方式打破智能指针的内部工作吗？
c++ ×11
weak-ptr ×11
shared-ptr ×10
c++11 ×5
c++14 ×1
class ×1
destructor ×1
exception ×1
lambda ×1
make-shared ×1
reference ×1