我有一个std::vector特定类的对象A.该类非常重要,并且定义了复制构造函数和移动构造函数.
std::vector<A> myvec;
如果我用A对象填充向量(使用例如myvec.push_back(a)),则向量将增大,使用复制构造函数A( const A&)来实例化向量中元素的新副本.
我可以以某种方式强制执行类的移动构造函数A而不是使用它吗？
我编写了一个简单的程序,可以在标准库容器中就地创建对象.这就是我写的:
#include <vector>
#include <iostream>
class AB
{
public:
explicit AB(int n);
AB(const AB& other) = delete;
AB(AB&& other);
AB& operator=(const AB& other) = delete;
AB& operator=(AB&& other) = default;
private:
int i;
};
AB::AB(int n): i( n )
{
std::cout << "Object created." << std::endl;
};
AB::AB(AB&& other): i( std::move(other.i) )
{
std::cout << "Object moved." << std::endl;
};
int main()
{
std::vector< AB > v;
v.emplace_back(1);
v.emplace_back(2);
v.emplace_back(3);
};
我用g ++(版本4.8.2)编译它.运行输出后,我得到:
Object created.
Object created.
Object moved.
Object …std::vector<std::string>在调用以下代码时如何初始化自身
std::vector<std::string> original;
std::vector<std::string> newVector = original;
这似乎好像拷贝构造函数会被调用的std::vector<std::string> new过程中newVector = original,却怎么都std::string带来了内部的orginal？它们是复制品还是新品std::string？内存newVector[0]也是如此original[0].
我问的原因是我做了以下事情
#include <vector>
#include <string>
using namespace std;
vector<string> globalVector;
void Initialize() {
globalVector.push_back("One");
globalVector.push_back("Two");
}
void DoStuff() {
vector<string> t = globalVector;
}
int main(void) {
Initialize();
DoStuff();
}
t将超出DoStuff(在非优化版本中)的范围,但是如果它t只是填充了指向std::strings in的指针globalVector,可能会调用析构函数并std::string删除所使用的内存,那么globalVector[0]填充垃圾std::string后会DoStuff是叫什么名字？
一个坚果壳,我基本上问,当std::vector调用复制构造函数时,里面的元素是如何被复制的？
我正在阅读C++ Primer,3rd Ed(Lippman和Lajoie),并且它说当需要重新分配向量以便为添加的更多元素腾出空间时push_back(),元素在新空间中被复制构造然后是析构函数被称为旧元素.我很困惑为什么这是必要的 - 为什么数据不能一点一点地复制？我假设答案与动态内存分配有关,但我目前的推理方法是,即使向量元素处理动态内存,实际存储在元素中的数据也将是指针,这意味着按位复制将保留它们指向的位置并且不会出现任何问题.我可以看到如何重新定位元素指向的动态分配的内存将是一个问题,因为它会使指针无效,但据我所知,向量重新定位没有理由这样做.
有人能给我一个不应该逐位移动的类的简单例子吗？
我想知道为什么在下面的C++代码中,复制构造函数被调用25次10次迭代？
如果它是10那么好10/10 = 1,或者20/10 = 2,或者30/10 = 3,但是25/10 = 2.5？这.5意味着什么？
标题:
class Person
{
public:
Person(std::string name, int age);
Person(const Person &person);
const std::string &getName() const;
int getAge() const;
private:
std::string name;
int age;
};
资源:
Person::Person(string name, int age) : name(std::move(name)), age(age)
{}
Person::Person(const Person &person)
{
this->name = person.name;
this->age = person.age;
static int count = 0;
count++;
cout << ">>Copy-Person::Person(Person &person) " << count << endl;
} …有了代码,我有以下输出:
A::A() is called
test #1
A::A(const A & other) is called
test #2
A::A(const A & other) is called
A::A(const A & other) is called
test #3
A::A(const A & other) is called
A::A(const A & other) is called
A::A(const A & other) is called
在调试代码时,对于3个测试用例,我发现第一次复制构造函数的调用是相同的(我认为这是有意义的):制作对象的副本并推送到向量.
但是,通过"_Umove_if_noexcept"对复制构造函数进行额外调用.
对于测试#2,当vec已经有一个条目时,它将进一步调用复制构造函数的一次.
对于测试#3,当vec已经有两个条目时,它将进一步调用复制构造函数的两倍.
这在Visual Studio 2017和gcc 5.4.0上是可重现的.
为什么会这样？是否存在性能问题？
谢谢
#include <iostream>
#include <vector>
class A
{
public:
//constructor
A()
{
a = 10;
std::cout << "A::A() is called" << std::endl;
}
//copy constructor …我想了解以下代码中复制构造函数的双重调用的原因：
#include <vector>
#include <thread>
#include <algorithm>
#include <functional>
#include <iostream>
#include <mutex>
std::mutex m_stdout;
class MyWorker {
public:
MyWorker() = default;
MyWorker(const MyWorker& mw) {
m_stdout.lock();
std::cout << "MyWorker coping" << std::endl;
m_stdout.unlock();
}
void operator() () {}
};
int main () {
std::vector<std::thread> vth;
vth.reserve(4);
MyWorker mw;
for (int i = 4; i > 0; --i) {
vth.emplace_back(mw);
}
std::for_each(vth.begin(), vth.end(), std::mem_fn(&std::thread::join));
}
标准输出：
MyWorker coping
MyWorker coping
MyWorker coping
MyWorker coping
MyWorker coping
MyWorker coping
MyWorker coping …