更新时间:2022-01-25 18:58:03
欢迎大家来我的博客逛逛????:hauhau.cn
R("string...")
示例:
#include <iostream>
int main() {
std::string str = R"(../../text.cc
上面换了个行)";
std::cout << str << std::endl;
}
[Running] cd "/root/code-server/c11-new/" && g++ 字符串字面量.cc -o 字符串字面量 && "/root/code-server/c11-new/"字符串字面量
../../text.cc
上面换了个行
[Done] exited with code=0 in 0.269 seconds
这个没什么好说的,替换 NULL 使用即可,这玩意不等于 0
auto 只能推导初始化了的变量
decltype 根据表达式进行推导: decltype (表达式)
decltype 的特殊情况:
()
包围,推导出来的是表达式类型的引用骚操作:
/**
* @brief 阻塞等待 set_value
* @return ret_type
*/
auto get_return() -> decltype(p_.get_future().get()) {
return p_.get_future().get();
}
/**
* @brief 阻塞等待 set_value
* @return ret_type
*/
decltype(auto) get_return() {
return p_.get_future().get();
}
没啥好说的
如题:
template<typename ret_type=int>
decltype(auto) get_return(ret_type _ret) {
return _ret
}
要注意的是,函数模板默认参数没有函数默认参数的默认参数都必须在右边的限制,想放哪就放哪
允许构造函数调用其他构造函数,建议在初始化列表中使用
public:
explicit TestTask(std::string _name) : name_(std::move(_name)) {};
TestTask(std::string _name, const std::string& _text) : TestTask(std::move(_name)) {
std::cout << _text << std::endl;
}
派生类可以直接使用基类的构造函数: using qualifier::name;
class TestTask : public XTask<std::string> {
public:
std::string name_;
public:
TestTask() = default;
explicit TestTask(std::string _name) : name_(std::move(_name)){};
}
class Task : public TestTask {
public:
using TestTask::TestTask;
};
也可以通过这种方式来使用基类的隐藏的同名函数
一个轻量的类模板,通过这个模板可以实现任意长度参数的传递
传参的时候可以通过实例化 std::initializer_list
或者使用初始化列表 { }
来进行传参
#include <iostream>
template<typename T>
void set_return(std::initializer_list<T> _list) {
for (const auto &i : _list){
std::cout << i;
}
std::cout << std::endl;
}
int main() {
std::initializer_list<int> list{1, 2, 3, 4, 5};
set_return(list);
set_return({1, 2, 3, 4, 5});
return 0;
}
同时也可以在构造函数中使用 std::initializer_list
来传递多个实参
for (const auto &i : _list){
std::cout << i;
}
其实就是使用迭代器来遍历容器
for (auto it = _list.begin(); it != _list.end(); ++it){
std::cout << i;
}
人话:能对表达式取地址的是左值,否则为右值,即:有名字的变量或对象都是左值,右值都是匿名的
右值又分两种:
右值引用:
class Test {
Test() = default;
}
Test GetTest() {
return Test();
}
int main() {
int &&value = 666;
Test &t = GetTest();
Test &&t = GetTest();
const Test &t = GetTest();
return 0;
}
666 是纯右值,int &&value = 666;
没毛病
Test &t = GetTest();
将一个右值赋值给左值引用,出大问题;Test &&t = GetTest();
就没毛病
const Test &t = GetTest();
有点特殊:常量左值引用是一个万能引用类型,可以接受左值、右值、常量左值、常量右值
为什么使用右值引用?
充分利用临时变量,减少不必要的拷贝