标签: deleted-functions

我想知道为什么这个程序不能编译(msvc,gcc和clang上的相同行为):

#include <iostream>

using namespace std;

struct Action
{
    virtual void action()
    {
        cout << "Action::action()\n";
    }
};

struct ActionDecorator : Action
{
    ActionDecorator(const ActionDecorator&) = delete;
    ActionDecorator(Action & action) : origAction(action)
    {
    }

    void action() override
    {
        decoration();
        origAction.action();
    }

private:
    void decoration()
    {
        cout << "ActionDecorator::decoration()\n";
    }

    Action & origAction;
};

int main()
{
    Action action;
    ActionDecorator actionDecorator(action);
    ActionDecorator actionDecorator2(actionDecorator);
    actionDecorator2.action();
}

根据我的期望,删除的拷贝构造函数应该让其他ActionDecorator实例构造ActionDecorator,因为它是Action的多态类型.相反,我必须显式地将ActionDecorator实例转换为Action并且因为编译器抱怨尝试引用已删除的复制构造函数.是否有一些解释这种行为的标准规则？

我在代码库中广泛使用了std :: mutex.但是,其中一个类只是不允许我在其实例变量列表中添加互斥锁.我正在使用以下内容简单地实例化互斥锁 -

std::mutex myMutex;

我将上述语句添加到类成员列表的私有部分.

我收到以下错误 -

error C2280: 'std::mutex::mutex(const std::mutex &)' : attempting to reference a deleted function
1> C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include\mutex(113) : see declaration of 'std::mutex::mutex'

我试图添加互斥锁的类被复制.

正如我所说的,我在我的代码库中使用了互斥锁,所以我可以在一个地方实例化互斥锁,而我可以在所有其他地方实例化,这是非常奇怪的.你能告诉我这里出了什么问题吗？

我有以下类示例,从较大的项目中简化.它基于一个日志框架,它使用记录器的作用域来终止析构函数中的日志条目.

下面的代码将无法编译,因为构造函数是一个隐式删除的函数(编辑:不是真),这似乎与std::ostringstream对象有关.我对此感到困惑,因为我认为我应该能够直接构造一个std::ostringstream,这意味着我应该能够直接构造一个Container对象.

#include <iostream>
#include <sstream>

class Container {
  public:
    std::ostringstream  bufferStream;

  public:
    Container();    // constructor
    ~Container();
};

Container::Container() {
    bufferStream << "Hello ";
}

Container::~Container() {
    std::cout << bufferStream.str() << " [end]" << std::endl;
}

// === Main method ===

int main() {

    Container().bufferStream << "world";   // works fine

    {                                      // causes tons of compiler errors
        Container cont = Container();
        cont.bufferStream << "world!";
    }

    return 0;
}

请注意,标记为"正常工作"的行就是这样做的.它似乎实例化了一个匿名Container对象,它包含一个新的std::ostringstream …

我正在尝试合并两个向量unique_ptr(即std::move它们从一个到另一个),并且我继续遇到"使用已删除的函数..."错误文本的墙.根据错误,我显然试图使用unique_ptr已删除的复制构造函数,但我不确定原因.以下是代码:

#include <vector>
#include <memory>
#include <algorithm>
#include <iterator>

struct Foo {
    int f;

    Foo(int f) : f(f) {}
};

struct Wrapper {
    std::vector<std::unique_ptr<Foo>> foos;

    void add(std::unique_ptr<Foo> foo) {
        foos.push_back(std::move(foo));
    }

    void add_all(const Wrapper& other) {
        foos.reserve(foos.size() + other.foos.size());

        // This is the offending line
        std::move(other.foos.begin(), 
                  other.foos.end(), 
                  std::back_inserter(foos));
    }
};

int main() {
    Wrapper w1;
    Wrapper w2;

    std::unique_ptr<Foo> foo1(new Foo(1));
    std::unique_ptr<Foo> foo2(new Foo(2));

    w1.add(std::move(foo1));
    w2.add(std::move(foo2));

    return 0;
}

#include<iostream>
#include<utility>
#include<tuple>
#include<functional>
using namespace std;
int main()
{
    int i = 0;
    auto p = make_pair(ref(i), ref(i++));
    p.first++;
    p.second++;
    cout << "i = " << i << endl;
}

例如,如果我这样使用ref(),编译器会说

使用已删除的函数'void std :: ref(const _Tp &&)[with _Tp = int]'

但是,如果我的代码如下

#include<iostream>
#include<utility>
#include<tuple>
#include<functional>
using namespace std;
int main()
{
    int i = 0;
    auto p = make_pair(ref(i), ref(++i));
    p.first++;
    p.second++;
    cout << "i = " << i << endl;
}

我会成功获得输出i = 3,所以我无法理解为什么我会得到如此不同的答案.

给出以下玩具代码：

class X
{
public:
    X() { }
    X(const X&) { }
    //X(X&&) = delete;
};

int main()
{
    X x;
    X y = std::move(x);
}

我知道X::X(X&&)在这种情况下它被隐式删除，因为它X(const X&)作为用户声明的构造函数存在。但我对这里术语“隐式删除”的含义有点困惑：如果我们取消注释，代码的行为会有所不同，这意味着隐式删除和“显式”删除X(X&&) = delete;之间存在差异。