相关疑难解决方法(0)

从根本上隐含地声明了四个特殊功能.

1. 默认构造函数
2. 默认析构函数
3. 默认赋值运算符
4. 默认的成员复制运算符

题:

如果用户定义了其中任何一个,[例如:析构函数]将不会声明这三个函数的其余部分.那是对的吗？或者它只适用于默认构造函数,并复制构造函数？

在C++ 11中测试线程时,我创建了以下示例:

#include <iostream>
#include <thread>

class Foo {
public:
    Foo(void) {
        std::cout << "Constructor called: " << this << std::endl;
    }
    ~Foo(void) {
        std::cout << "Destructor called: " << this << std::endl;
    }
    void operator()() const {
        std::cout << "Operatior called: " << this << std::endl;
    }
};

void test_normal(void) {
    std::cout << "====> Standard example:" << std::endl;
    Foo f;
}

void test_thread(void) {
    std::cout << "====> Thread example:" << std::endl;
    Foo f;
    std::thread t(f);
    t.detach();
}


int main(int …

我是c ++ 11的新手,并编写了以下代码来了解其std::move工作原理:

#include <queue>
#include <stdio.h>

class X {
 public:
  X(int x) : x_(x) {}
  ~X() {
    printf("X(%d) has be released.\n", x_);
  }

  X(X&&) = default;
  X& operator = (X&&) = default;

  X(const X&) = delete;
  X& operator = (const X&) = delete;
 private:
  int x_;
};


int main() {
  std::queue<X> xqueue;
  for (int x = 0; x < 5; ++x) {
    xqueue.push(std::move(X(x)));
  }
  return 0;
}

但是,它会生成以下输出,表示每个的析构函数X(n)都被调用了两次:

X(0) has be released.
X(1) has be …

我知道五法则，它指出如果你实现一个析构函数，你很可能还应该实现一个复制构造函数、复制赋值运算符、一个移动构造函数和一个移动赋值运算符。

但是，如果我实现了一个移动运算符，我是否绝对必须实现一个副本副本，还是只是最佳实践？

我有以下问题:

当我使用std :: vector和内置函数时,我没有得到内存,但如果我使用类,我会得到内存泄漏.为了显示:

//No leak
std::vector<double>* vecPtr1=new std::vector<double>();
//add some elements
delete vecPtr1;

//Leaks some memory but not all
std::vector<SomeClass>* vecPtr2=new std::vector<SomeClass>();
//add some elements with vecPtr2->push_back(SomeClass());
delete vecPtr2;

据我所知,删除应该调用std :: vector的析构函数,它应该依次调用SomeClass的析构函数 - >无泄漏.我已经投入了一些思考和测试,如果我在这样的范围内使用std :: vector会发生同样的行为:

{
  std::vector<SomeClass> vector;
  //add elements as before
}
//memory is still used here

我在Ubuntu 11.10下使用gcc 4.6.1.在我的库中有什么不对,或者我对std :: vector如何破坏元素有误解？

为了澄清我的SomeClass的完整代码替换为std :: pair(是的,我知道有些部分被黑了,但它只是一个例子):

#include <iostream>
#include <vector>
#include <utility>

int main()
{
    std::string inString;
    std::cout<<"Started"<<std::endl;
    //wait
    std::cin>>inString;
    {
        //assign vector
        std::vector<std::pair<std::string,unsigned int> > vec=std::vector<std::pair<std::string,unsigned int> …

如果我有一个管理一些动态内存的类(例如矢量类型)并且它已经有一个移动构造函数,为函数提供移动感知重载是否有意义,或者移动构造函数是否有意义照顾它？

例如,我应该使用Class&&变量重载哪些(如果有的话):

// the move-aware overload for all of these would be
// void FuncX(Class&&);

void Func1(Class);

void Func3(Class&); // doesn't make a local copy
void Func4(Class&); // makes a local copy

void Func5(Class const);

void Func7(Class const&); // doesn't make a local copy
void Func8(Class const&); // makes a local copy

他们中的任何一个都失去了优化机会,因为我没有提供移动感知变体吗？

在Stroustrup的C++之旅中,他提到:

如果您明确指出某些默认值,则不会生成其他默认定义.

但是,gcc 4.9.1似乎并非如此.举个例子:

#include <iostream>
using namespace std;

struct A 
{
    int data;
    A() = default;
    A(const A&) = default;
};

int main() 
{

  A a;
  a.data = 10;
  A b(a);
  A c;
  c = a;

  cout<<b.data<<endl;
  cout<<c.data<<endl;
  return 0;
}

它编译并给出预期的输出.即已生成默认赋值运算符.

我是否误解了Stroustrup的评论？

在C中,我们实际上做到了

struct node *p = (node*)malloc(sizeof(node));   // casting is not necessary
p->a = 0;      // first  element
p->b = NULL;   // second element

动态分配内存中的空格,但我怎么能用C++方式呢？

线下面是正确的猜测吗？

node *p = new node {0, NULL};

以下代码导致断言错误.此外,警告错误消息表示检测到堆损坏.

class A {
    int* a; // dynamic array of ints
    A() {};
    A(int size) {
        a = new int[size]; 
    }
    ~A() {
        delete [] a;
        a = nullptr;
    }
}

*** in code somewhere ***
int size = 5;
A temp = A(size);

我有这样的代码:

class A
{
public:
    A(void);
    ~A(void)
    {
        delete b;
        delete c;
        delete d;
        // ...
    }
private:
    B* b;
    C* c;
    D* d;
    // ...
};

//A.cpp
    A(void) : b(new B()), c(new C()), d(new D()) //...
    {  
    }

类A取得所有权在自己的对象b,c,d...什么是保持这些对象的最佳方式？我猜,std::unique_ptr<B/C/D>类型的使用将适合这种方式.例如,它允许不关心析构函数的仔细编写.