标签: object-lifetime

所以我在c ++中创建了一个有2个引用类型成员的类:

class Edge{
private:
const Node& base;
const Node& target;

public:
    Edge(const Node& new1, const Node& new2);

我想在C'tor中给出base和target的默认值.意思就是:

Edge()

不会出错,但会创建一个Edge对象.我怎么做？

编辑:我也想做:

Edge::Edge(const Node& newBase, const Node& newTarg)
{
    m_base=newBase;
    m_target=newTarg;
}

但它不会让我,它说没有运营商"="匹配这些运营商.但我确实为节点做了一个"="运算符并检查它是否有效.......

在并行应用程序中,线程组中的线程(32)使用共享的非托管和独立的一次性对象.

我们在c/c ++应用程序中有相同的东西,我shared_ptr<>在那里使用以便在不需要对象之后让对象进行处理和最终化.

我只是尝试在Java中应用相同的东西,我面对的finalize()方法.但是有一些问题,因为GC有时是如此懒惰,对象甚至没有被识别为处理/终结的无法访问的对象,有时它被调用,但没有保证GC让对象finalize()完全调用.

所以我刚刚带来了另一个复杂的解决方案,我只是倒计时并跟踪线程正在使用它不起作用的对象,但我知道这不是一个可靠的解决方案,我知道我将面临意想不到的结果.

我只是想知道shared_ptr<>在java中是否有相同的东西,或者是否可以通过JNI处理该对象？

有任何想法吗？

根据cppreferences,explicit runtime_error( const std::string& what_arg );不会复制what_arg的内容.

我可以安全地将临时字符串对象传递给std::runtime_error's ctor？

例如:

std::string GetATempString(const char* msg)
{
    return { msg };
}

int main()
{
    try {
        throw std::runtime_error(GetATempString("Hello"));
    } catch (const std::runtime_error& e) 
    {
            e.what(); // Is it guaranteed that "Hello" would be returned safely?
    }
}

执行以下程序时应该怎么办？

#include <iostream>
#include <memory>

class test;
std::shared_ptr<test> a_test_object;
struct test
{
    ~test()
    {
        std::cout << "destroy test" << std::endl;
        auto ptr = a_test_object;
    }
};

int main()
{
    a_test_object = std::make_shared<test>();
    //a_test_object.reset();  // Uncomment this and it works fine.
}

我在GCC和Visual Studio 2015上测试了这个,在这两种情况下程序都崩溃了.发生的事情是共享指针在其析构函数中递减计数,然后执行~test(),复制共享指针递增然后递减计数,触发对~test()的无限递归调用.奇怪的是,调用reset()不会触发问题.

我今天碰到了这个,因为使用了一个没有这个双重删除错误的前C++ 11版本的shared_ptr的旧代码被更新为使用std :: shared_ptr.令我惊讶的是,std :: shared_ptr导致程序崩溃.这真的是std :: shared_ptr的预期行为吗？

有什么办法可以在另一个类的更多实例上共享一个变量(类的对象)？静态成员不是我想要的.我知道一个变量(大对象)将在更多实例之间共享(但不是所有实例).我怎么能用C++做到这一点？谢谢你的帮助.

例:

class ClassA {
public:
   ...
private:
   ClassB object; // this variable will be shared among more instances of ClassA
}

我是C++的新手,因此这个问题.我在C++中有一个单一链接列表的玩具实现.

template<typename T>
class List {
    template<typename U>
    struct Node {
        U data_;
        Node<U>* next_;

        Node() : data_(0), next_(nullptr) {}
        Node(U data) : data_(data), next_(nullptr) {}
    };

private:
    Node<T>* head_;
    std::size_t size_;

public:
    List() : head_{nullptr}, size_{0} {}

    void insert(const T& item) {
        Node<T>* p(new Node<T>(item));
        if (size_ == 0) {
            head_ = p;
        } else {
            p->next_ = head_;
            head_ = p;
        }
        size_++;
    }
    std::size_t getSize() {
        return size_;
    }

    ~List(){
    while(head_){
        Node<T> p = head_;
        delete(p);
        head_ …

我正在处理具有以下问题的应用程序.基本上有很多对象可能会破坏自己.

void Foo::func()
{
    ...
    Bar b;
    b.func2();
}

这func2可能会破坏foo调用它的对象.由于不太可能发生这种情况,我想确保foo在此调用之后无法访问该对象的任何成员变量,因为我无法保证它们仍然有效.如果对b的这个调用是最后一次调用我完全没问题,但由于我不是唯一一个在这个项目上工作且破坏不明显的人,我想this在这些调用之后实现阻止使用的东西.有没有办法在不完全重构当前设计的情况下实现这一点(因为它在整个项目中广泛使用)？

一些背景信息:

它是一个Qt UI应用程序,它使用QML来跟踪一堆"屏幕"(屏幕是QML +它对应的C++模型).Bar我的例子中的类是'堆栈管理器',它控制着屏幕的生命周期.这是一个单身人士(我知道).的Foo类为特定QML一个C++模型.该函数Foo::func()是一个可以从QML中的用户输入或其他系统事件调用的函数.该函数通常处理事件,但偶尔它可以告诉屏幕管理器删除一个或多个屏幕,这些屏幕又删除对应于该屏幕的模型(可能是调用模型).