相关疑难解决方法(0)

简单的问题,为什么不做以下工作(暗示副本ci)？

#include <utility>

int main(){
  const int ci = 2;
  std::forward<int>(ci);
}

prog.cpp:在函数'int main()'中:
prog.cpp:6:23:错误:没有用于调用'forward(const int&)'的匹配函数

在编写一些模板内容时,问题就出现了,我有一个简单的持有者类型,如下所示.为了避免不必要的副本,我尽可能使用完美转发,但结果证明它似乎是问题的根源.

template<class T>
struct holder{
    T value;

    holder(T&& val)
        : value(std::forward<T>(val))
    {}
};

template<class T>
holder<T> hold(T&& val){
    // T will be deduced as int, because literal `5` is a prvalue
    // which can be bound to `int&&`
    return holder<T>(std::forward<T>(val));
}

template<class T>
void foo(holder<T> const& h)
{
    std::tuple<T> t;  // contrived, actual function takes more parameters
    std::get<0>(t) = std::forward<T>(h.value); …

如果a具有包含标准和复制构造函数的类

class Ex{
       //constructor definitions
}

以及将其作为参数的函数(按值)

void F(Ex _exin){...}

采取以下代码:

Ex A;
F(A);   //F's parameter is copy constructed from A
F(Ex());  //F's parameter uses the default constructor

在第三行中,我使用默认构造函数向F传递Ex类的新(临时)对象.我的问题是:在创建这个新对象后,它还复制构造/分配(就像它发生在第二行)或者它是直接创建"内部" F？

我想在一个抽象类的std :: vector中存储从公共接口(抽象类)派生的类的对象.这个向量应该填充一个循环,通常我会调用类的构造函数并将创建的对象推送到向量中.

据我所知,在抽象类的情况下,我只能存储指向该类的指针,所以我需要push_back派生类的指针.但是,我不确定这些新创建的对象的范围.

请看下面的代码.这段代码编译并正常工作,但我的问题是:

a)对象是否保证存在于main函数的第二个for循环中？或者他们可能会停止存在超出创建它们的循环范围？

b)是否所有对象的析构函数都被调用或存在内存泄漏？

#include<vector>
#include<iostream>
class Interface {
    public:
    Interface( int y ) : x(y) {}
    virtual ~Interface() {}
    virtual void f() = 0;
    int x;  
};

class Derived_A : public Interface {
    public:
    Derived_A( int y ) : Interface(y) {}
    void f(){ return; }
};

class Derived_B : public Interface {
    public:
    Derived_B( int y ) : Interface(y) {}
    void f(){ return; }
};


int main()
{
    std::vector<Interface*> abstractObjects;
    int N = 5;
    for(int ii …

我有一个类MyClass拥有某个类的实例,DataProvider并为此有一个getter.

为了依赖注入,我宁愿有一个getter和一个setter.此外,DataProvider应包含在std::unique_pointer:

#include <memory>
#include <iostream>

class DataProvider
{
public:
    DataProvider() {}
    virtual ~DataProvider() {}
    /* stuff */

private:
    /* more stuff */

};

class MyClass
{
public:
MyClass() {}

    virtual inline const DataProvider &getDataProvider() const
    {
        return *data;
    }
    void setDataProvider(std::unique_ptr<DataProvider> newData)
    {
        data = std::move(newData);
    }

private:
    std::unique_ptr<DataProvider> data;
};

我读过这个:如何将unique_ptr参数传递给构造函数或函数？

但它不包括吸气剂部分.这(上面)是正确的方法吗？还有什么可以想到的？

嗯,我认为这个问题几乎总结了一下.我有一个独特项目的forward_list,并希望从中删除一个项目:

std::forward_list<T> mylist;
// fill with stuff

mylist.remove_if([](T const& value)
  {
    return value == condition;
  });

我的意思是,这种方法工作正常但效率低,因为一旦找到并删除了项目,它就会继续搜索.有更好的方法还是我需要手动完成？

我明白这std::unique_ptr是它的方式,可能不会改变以打破向后兼容性,但我想知道是否有人有充分的理由为什么规范的编写者没有get使用看起来像const变量的方法重载方法

const T* get() const;

跟随的意图unique_ptr存在const.

我最好的猜测是它试图镜像指针,T* const而不是典型的类.作为一个后续问题,如果我想在我的类的const实例中以类似const的方式持有一个指针,我应该使用除了std::unique_ptr保存数据之外的其他东西吗？

更新

在我的情况下,我想保护自己免于滥用类本身的指针.我正在编写一个const移动构造函数MyClass(const MyClass&& other),并将数据从新实例复制到其他via std::copy.我花了很长时间来追踪这个bug,因为我认为副本必须是正确的,因为const保护.我试图找出我可以做些什么来保护自己,除了提供一个const getter并在进行复制时在类中使用它.

首先,这个问题是不是重复的功能双到std ::移动？或者std :: move的反转是否存在？.我不是要问一种机制,以防止在原本会发生的情况下移动,而是复制; 相反,我正在询问一种机制,使rvalue被接受在一个将被绑定到可修改左值引用的位置.事实上,这std::move与发明的情况完全相反(即,在一个将被绑定到(可修改的)右值参考的位置上接受可修改的左值).

在我感兴趣的情况下,不会接受右值,因为上下文需要可修改的左值引用.由于某种原因,我不太明白但愿意接受,(可修改的)右值表达式将绑定到一个常量左值引用(不引入额外的临时值),但它不会绑定到可修改的左值引用( gcc给我的错误信息是"从'A'类型的右值'中'A&'类型的非const引用的无效初始化",而clang说"对类型'A'的非const左值引用不能绑定到临时的输入'A'';奇怪的是我无法让这些编译器中的任何一个承认有问题的表达式有'A &&'类型,即使该表达式实际上是static_cast<A&&>(...)单独引发错误的形式.我可以理解,通常不希望在需要可修改的左值引用的位置接受rvalue表达式,因为它意味着通过该左值引用完成的任何修改都将丢失,但正如调用std::move对编译器说的那样"我知道这是一个左值,它将被绑定到右值参考(参数),因此可能会被盗,但我知道我在做什么,这里没关系"我想在我的案例中说"我知道这是临时的,它将被绑定到一个可修改的左值引用(参数),因此通过左值引用所做的任何更改都会被忽略,但我知道我在做什么,这里没关系".

我可以通过从rvalue 初始化类型A 的命名对象,然后提供需要可修改左值引用的名称来解决问题.我不认为这有额外的运行时开销(无论如何都需要rvalue的临时开启),但是必须这样做在几个方面很尴尬:必须引入一个虚拟名称,可能只需引入一个复合语句保持声明,将产生rvalue的表达式与函数调用分开,它为其提供参数.我的问题是否可以在不引入虚拟名称的情况下完成:

1. 是否有任何方法(例如使用强制转换)将类型A的rvalue表达式绑定到类型A的可修改左值引用并且不引入类型A的命名对象？
2. 如果没有,这是一个刻意的选择吗？(如果是这样,为什么？)如果有,是否有类似于std::move标准提供的机制来促进它？

这是一个简化的插图,我需要这样的转换.我故意删除了A的特殊构造函数,以确保错误消息不涉及编译器决定引入的临时文件.当A&被替换时,所有错误都会消失const A&.

class A
{ int n;
public:
  A(int n) : n(n) {}
  A(const A&) = delete; // no copying
  A(const A&&) = delete; // no moving either
  int value() const { return n; }
};

int f(A& x) …

下面的最小工作示例在使用选项 1 或选项 2下的代码时编译，但在使用选项 3 下的代码时不编译。我假设emplace_back()隐式使用/调用move构造函数，那么为什么需要显式move()？跟r-valuevs. 有关系l-value吗？或者这是否与std::unique_ptr需要转让所有权有关？（我对这些概念还是陌生的，尤其是在这种情况下。）

为了完整push_back()起见，除非move()调用，否则选项 4 with也不会编译。

#include <iostream>
#include <vector>
#include <memory>

class Beta {
public:
    Beta(int x, int y, int z): mX(x), mY(y), mZ(z) { };
    int mX; int mY; int mZ;

};

class Alpha {
public:
    std::vector<std::unique_ptr<Beta>> betaVec;
    void addBeta(int x, int y, int z) {
        // only choose one of the following options:
        // option …

我有一个函数,它使用move-capture构造一个lambda函数(仅限C++ 1y)并返回它.

#include <iostream>
#include <functional>
#include <memory>

using namespace std;

function<int ()> makeLambda(unique_ptr<int> ptr) {
    return [ ptr( move(ptr) ) ] () {
        return *ptr;
    };
}

int main() {
    // Works
    {
        unique_ptr<int> ptr( new int(10) );
        auto function1 = [ ptr(move(ptr)) ] {
            return *ptr;
        };
    }

    // Does not work
    {
        unique_ptr<int> ptr( new int(10) );
        auto function2 = makeLambda( std::move(ptr) );
    }

    return 0;
}

然而,似乎在返回时,unique_ptr<int>调用了复制构造函数.为什么这个/我怎么能绕过这个？

链接到粘贴:http: //coliru.stacked-crooked.com/a/b21c358db10c3933

我有一个类有一个setter方法,它以unique_ptr作为参数.unique_ptr保存为类成员.

class TestClass {
    std::unique_ptr<Tester> sp;

    void setTester_Way1(std::unique_ptr<Tester> te) {
         auto deleter=std::move(sp);
         sp=std::move(te);
    }

    void setTester_Way2(std::unique_ptr<Tester> te) {
         sp=std::move(te);
    }
};

哪种方式是设置智能指针的正确方法？Way2是否泄漏sp的原始指针？