以此方法声明为例:
const Vector Vector::operator - ( const Vector& other ) const;
我知道第二个const使Vector作为参数传递为immutable,并且最后一个const声明该方法不会更改Vector类的当前实例....
const意味着什么或者导致什么呢？我想确认我对已push_back()在 .ed 上编辑的对象的生命周期的理解std::vector。我读到的内容是向量中的元素是副本。那么，下面的用法可以吗？具体来说，变量 s 是否位于f2()an 的不同实例中std::string，而不是push_back()'ed 中的变量f1()，因此可以安全使用？
void f1(std::vector<std::string>* pv) {
std::string s = "hi";
pv->push_back(s);
}
void f2(void) {
std::vector<std::string> v;
f1(&v);
for (size_t i = 0; i < v.size(); ++i) {
std::string s = v.at(i);
std::cout << s;
}
}
在Java中,包含适当对象的所有变量实际上都是引用(即指针).因此,使用这些对象作为参数的方法调用始终是"通过引用".调用修改对象状态的方法也会影响原始对象(在调用者端).
C++是不同的:这里的参数可以通过值传递或通过引用传递.在通过值传递的对象上调用mutator方法会使原始对象不受影响.(我想按值调用会创建对象的本地副本).
所以我对此的第一反应 - 从Java到C++ - 是:当使用对象作为参数时,总是使用指针.这给了我从Java期望的行为.
但是,如果一个人不需要修改方法体中的对象,也可以使用"按值调用".是否有人想要这样做？
给定已分配但未初始化的内存位置,如何将某个对象移动到该位置(销毁原始对象),而不构建可能昂贵的中间对象？
我对以下代码片段中发生的事情感到困惑.这move真的有必要吗？返回临时集的最佳+安全方法是什么？
set<string> getWords()
{
set<string> words;
for (auto iter = wordIndex.begin(); iter != wordIndex.end(); ++iter)
{
words.insert(iter->first);
}
return move(words);
}
我的调用代码就是这样 set<string> words = foo.getWords()
当我读一些文章时,我发现这条线是如此神秘.
new (new_ptr + i) T(std::move(old_ptr[i]));
有人可以解释这种语法是如何工作的吗？
我有一个包含std :: string的Text类.一个方法SetText如下:
void Text::SetText( const std::string& str )
{
m_str = str;
}
因为这个方法几乎总是以rvalues作为参数调用,所以我想到了移动构造函数.我理解基础知识,但这就是全部.所以我做了测试并得出结论,像这样的另一个函数会更好,一旦定义了移动构造函数和移动分配,就可以获得性能提升:
void Text::SetText( std::string&& str )
{
m_str = move( str );
}
有我的问题:
谢谢.
#include<iostream>
#include<stdio.h>
using namespace std;
class Test
{
public:
string n;
Test():n("test") {}
};
int main()
{
Test t1;
std::cout<<"before move"<<"\n";
std::cout<<"t1.n=" << t1.n<<"\n";
Test t2=std::move(t1);
std::cout<<"after move"<<"\n";
std::cout<<"t1.n="<<t1.n<<"\n";
std::cout<<"t2.n="<<t2.n<<"\n";
return 0;
}
上述程序的输出产生以下结果
移动前 t1.n=测试 移动后 t1.n= t2.n=测试
了解到，将对象 t1 移动到 t2 后，t2.n 的值结果为空字符串
但相同的概念移动概念不适用于整数。
#include<iostream>
#include<stdio.h>
using namespace std;
class Test
{
public:
int n;
Test():n(5) {}
};
int main()
{
Test t1;
std::cout<<"before move"<<"\n";
std::cout<<"t1.n=" << t1.n<<"\n";
Test t2=std::move(t1);
std::cout<<"after move"<<"\n";
std::cout<<"t1.n="<<t1.n<<"\n";
std::cout<<"t2.n="<<t2.n<<"\n";
return 0;
}
上述程序的输出产生以下结果 …
这可能是显而易见的,但我认为这对我来说很难.鉴于这种:
void test(std::string&&) { }
std::string x{"test"};
test(std::move(x)); // ok
此代码test() 使用rvalue引用作为参数调用,以便程序按照我的预期进行编译.
现在看看这个:
void other_test(const std::string&) { }
std::string x{"test"};
other_test(std::move(x)); // ok???
在这里,我倾斜了.为什么这个版本会编译？所述std::move返回一个&&类型; 为什么我在第二种方法中没有出现错误const&？
我知道
int&& s = 5;
const int& s = 5;
是有效的,因为在这两种情况下我提供的东西都没有左值,它没有地址.是&&与const&相同呢？如果不是,有区别吗？
我看到的代码如下：
template<class Function>
void MyFunc(Function&& function) { function(...); }
&&与仅按值复制函数相比，这里的优势是什么？作为参考，我使用的是 C++14。