学习C++：笔记

笔记"/>

学习C++：笔记

目录

• 宏定义
• lambda表达式
• 智能指针
• 引用折叠
• std::move
• 完美转发：std::forward
• 可变参数模板
• IO库的格式化输入与输出

宏定义

• #、##

#：将后面的参数字符串化

##：连接，将参数和原来的字符子串连接

#include <iostream>
#include <string>#define FOO(var) __define__name_##var
#define BAR(str) "__str__"#strint main() {std::string var = "test";std::string FOO(one) = BAR(var); //FOO(one) ==> __define_name_one//BAR(var) ==> __str__varstd::cout << FOO(one) << std::endl;//output: __str__varreturn 0;
}

• 可变宏：…和__VA_ARGS__

…最能在参数列表最后一个，__VA_ARGS__在文本替换中表示…

#include <cstdio>#define PRINT(first, ...) \
printf("__define__print_"#first": " __VA_ARGS__)
int main() {int num = 10;PRINT(int, "num: %d\n", num);//printf("__define__print_""int"": ""num: %d\n", num);//printf("__define__print_int: num: %d\n", num);//output: __define__print_int: num:10return 0;
}

lambda表达式

• 形式：

[capture list](parameter list) -> return type { function body }

auto func = [](const int &a) ->int {return a * 10;
};

• 捕获方式：

1. [] ：空捕获
2. [variables] ：捕获指定变量，variables用逗号分隔
3. [&] ：引用捕获，使用到的lambda外部变量的都是引用捕获方式
4. [=] ：值捕获，使用到的lambda外部变量都是值捕获方式
5. [&, variables] ：混合方式
6. [=, variables] ：混合方式

采用值捕获时，如果要修改捕获的变量，则需要在参数列表首加上mutable：

#include <iostream>
int main() {int v = 10;//auto f = [v] -> int {return ++v;}; //error: cannot assign to a variable captured by copy in a non-mutable lambdaauto f = [v]()mutable -> int {return ++v;};std::cout << f() << " v: " << v << std::endl;//output: 11 v: 10;return 0;
}
int v1 = 10;
auto func = [v1]()mutable -> int {return ++v1;};

智能指针

//TODO

引用折叠

对于给定一个类型T：

1. T&& & ==> T&

2. T& & ==> T&

3. T& && ==> T&

4. T&& && ==> T&&

   #include <iostream>template<typename _Tp>
   void func(T&& val) {T t = val;t++;std::cout << "t: " << t << " val: " << val << std::endl;
   }int main() {int i = 1;//传递的是int右值，T为int。func(10);	//output: t: 11 val: 10//传递的是int左值，T为int&，T& &&  ==>  T&func(i); //output: t: 11 val: 11return 0;
   }
   

std::move

• 定义

//<utility>
template <typename _Tp>
typename remove_reference<T>::type&& move(T&& _t)
{return static_cast<typename remove_reference<T>::type&&>(_t);
}

• 注意

1. move调用告诉编译器：有一个左值，但是希望像右值一样处理它。
2. 对一个变量使用move后，除了对变量赋值或者销毁它之外，我们将不再使用它，不能对移动后的对象的值做任何假设。
3. 使用std::move而不是直接使用move

完美转发：std::forward

当需要将一个或者多个参数连同类型不变地转发给其他函数时，可以使用std::forward.

可变参数模板

• 定义

template <typename _Tp, typename... Args>
void func(const T &t, const Args& ... args) //扩展Args
{return foo(args...); //扩展args
}
//使用...触发扩展操作

• sizeof…运算符

使用sizeof…可以知道包里有多少个元素

template <typename... Args>
void func(Args... args) {std::cout << sizeof...(Args) << std::endl; //类型参数的数目std::cout << sizeof...(args) << std::endl; //函数参数的数目
}

• 配合std::forward使用

template <typename... Args>
void func(Args&&... args)
{work(std::forward<Args>(args)...);//既扩展了模板参数包Args也扩展了函数参数包args
}

IO库的格式化输入与输出

• boolalpha和noboolalpha

std::cout << std::boolalpha << true << " " << std::noboolalpha << true << std::endl;
//true 1

• 进制

std::cout << 1024 << std::endl;             //10
std::cout << std::hex << 1024 << std::endl; //16
std::cout << std::oct << 1024 << std::endl; //8
std::cout << std::dec << 1024 << std::endl; //10
//hex, oct, dec只影响整型//使用std::showbase可以在打印时显示进制，noshowbase取消
//std::uppercase大写输出16进制，std::nouppercase取消

待更新…