小编cur*_*guy的帖子

我有以下课程

class a {
        std::shared_ptr<b> b_ref;
    public:
        a(std::shared_ptr<b> b_ref) : b_ref(b_ref) {}
};

class b {
        std::shared_ptr<a> a_ref;
    public:
        b(std::shared_ptr<a> a_ref) : a_ref(a_ref) {}
};

现在我想创建两个相互引用的对象有没有办法做到这一点？我认为使用c风格的指针我可以做到这一点.它也适用于共享指针吗？我尝试了reset()和swap()方法没有任何成功.

std::shared_ptr<a> a_ref;
std::shared_ptr<b> b_ref;

a_ref = std::make_shared<a>(b_ref);
b_ref = std::make_shared<b>(a_ref);

不工作.

我知道 const 引用会延长本地临时文件的寿命。现在我问自己是否可以在临时对象链上扩展此属性，也就是说，我是否可以安全地定义：

std::string const& foo = aBar.getTemporaryObject1().getTemporaryObject2();

我的感觉是，由于第一个方法aBar.getTemporaryObject1()已经返回了一个临时对象，因此不适用于aBar.getTemporaryObject2().

我不确定这个问题是否合适,但我会尽我所能.

这是我的作业问题.如果两条线平行或相等,则作业要求我抛出异常.

原始代码由我的教授提供,我的工作是修改它以使其能够抛出异常.

line.h

class RuntimeException{
 private:
 string errorMsg;
 public:
 RuntimeException(const string& err) { errorMsg = err; }
 string getMessage() const { return errorMsg; }
};

class EqualLines: public RuntimeException{
 public:
 //empty
};

class ParallelLines: public RuntimeException{
 public:
 //empty
};

class Line{
 public:
 Line(double slope, double y_intercept): a(slope), b(y_intercept) {};
 double intersect(const Line L) const throw(ParallelLines,
                    EqualLines);
 //...getter and setter
 private:
 double a;
 double b;
};

教授告诉我们不要修改头文件,只能修改.cpp文件.

line.cpp

double Line::intersect(const Line L) const throw(ParallelLines,
                       EqualLines){
 //below is my own code …

免责声明:我知道不应该使用unique_ptr,但为了便于理解,我想知道这里发生了什么.谢谢!

考虑这个功能:

void foo(int* a) {
    unique_ptr<int> pointer_in_function(a);
}

而这个主要功能:

int main(void) {
    int* myInt = new int(5);
    unique_ptr<int> pointer_in_main(myInt);

    foo(myInt);

    cout << *pointer_in_main << endl;
    cout << *pointer_in_main << endl;

    cin.get();
    return 0;
}

我一直从第一个cout得到正确的答案.第二个是未定义的.该程序有时会在退出时出现严重错误而崩溃,但并非总是如此.

我不明白为什么第一个cout一致地给出了正确的答案.当pointer_in_function超出范围时,myInt指向的整数是否应该被删除？谢谢您的帮助!

编辑:顺便说一句,为了确保,我在假设调用foo应该删除我的整数是正确的,因为pointer_in_function超出了范围？

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

#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的预期行为吗？

#include <iostream>
#include <memory>

class Base
{
public:
    virtual void foo() = 0;
};

class Derived : public Base
{
public:
    void foo() override { std::cout << "Derived" << std::endl; }
};

class Concrete
{
public:
    void Bar() { std::cout << "concrete" << std::endl; }
};

int main()
{
    std::unique_ptr<Concrete> ConcretePtr = nullptr;
    ConcretePtr->Bar();
    std::unique_ptr<Base> BasePtr;
    BasePtr->foo();
    return 0;
}

我假设将一个unique_ptr声明为具体类型Concrete,为类型的对象分配内存,Concrete而unique_ptr开始指向它.我的假设/理解是否正确？我问,因为ConcretePtr->Bar();打印机"混凝土"到控制台.但是,如果我创建一个指向接口的唯一指针Base,它不知道我需要的确切对象类型,也不知道在内存中分配/获取资源.

这失败BasePtr->foo();了BasePtr._Mypair._Myval2 was nullptr.

为什么第一个声明std::unique_ptr<Concrete> ConcretePtr = nullptr; …

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

例:

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

是静态还是动态类型的expr使用sizeof expr？

请引用C++ 17标准.

对于C数组，通常情况下，简单地命名数组与编写&foo[0]将近50年的东西具有相同的效果。

在我正在处理的项目中，从C样式数组转换为std :: array <>时，出现的绝大多数“错误”是由于C数组的上述属性所致。

在所有情况下，解决方案都很简单，只需追加即可.data()。但是，我想到精心设计operator T*应该可以直接解决这个问题。

有任何技术原因无法创建此运算符？

C或C ++语言语义与用户形成矛盾。一些构造对它们的行为没有任何限制，这是由于在某些情况下（例如，取消引用未指向对象的指针，例如空指针）没有指定的行为，或者是通过明确地未定义。在任何一种情况下，都不能保证以下行为。

但是过去呢？这些已定义行为并产生输出的指令。我想可以删除输出，但是以前的交互可能在过去已经观察到。

未定义的行为是否可以预先确定，从而不会产生某些输出？例如：

std::cout << "hello, world" << std::endl; // with a flush
float f = 1./0.; // UB: cancels previous syscall?

不会在这里进行writesyscall（假设是Unix）吗？

现在该内存模型如何？可以保证对原子对象，互斥体以及所有顺序一致的操作的所有操作均具有顺序（每个命令均与指令流一致，但不一定要有并集）；如果程序表现出未定义的行为，什么时候适用保证？

在程序执行的某个时刻，实现可以使用未定义的行为作为不遵守内存模型要求的借口吗？换句话说，语言语义（用户）的合同客户可以在何时实现这些要求（在I / O上，在操作顺序上）？

澄清：只有格式正确的程序

（我意识到我可能没有我想要的那么具体。）

一些其源代码违反一致性或健全性规则的程序：

• 违反一个定义规则
• 没有有效专业化的模板
• 在不同点绑定到不同名称的模板

被描述为完全无效。编译器可以通过诊断拒绝这些程序，也可以对其进行编译，但是在那种情况下，该程序的执行未定义行为。让我们将其称为“ 先验 UB”。

问题不是关于那些程序，而是关于结构良好的程序，这些程序至少可以在一段时间内执行良好的定义。