一般是找不到库，有几种方法：
临时方法
export LD_LIBRARY_PATH=/usr/local/mysql/lib:$LD_LIBRARY_PATH
本用户永久方法
把上面那个 export 写入到 .bashrc里面。
echo "/usr/local/lib" >> /etc/ld.so.conf
ldconfig参考: https://blog.csdn.net/wanxuexiang/article/details/84574660
doxygen + graphviz 可以清晰表达类和函数之前的嵌套调用关系。
wget ftp://user:pwd@10.10.10.10/xyz.txt
这是现在不同标准下给出的扩展名： Unix： C, cc, cxx, c
GNU C++： C, cc, cxx, cpp, c++
Digital Mars： cpp, cxx
Borland： C++ cpp
Watcom： cpp
Microsoft Visual C++： cpp, cxx, cc
Metrowerks CodeWarrior： cpp, cp, cc, cxx, c++
https://curl.se/download.html 这个地址下载 win64 的 mingw 版本的 libcurl 二进制文件。然后解压，发现 lib 文件夹下面有两个库文件，libcurl.a 和 libcurl.dll.a.
在网上搜索了一圈，都没有找到相关的解释，最后还是在解压出来的文件里面找到了说明。curl-7.77.0-win64-mingw\docs\FAQ.txt 这个里面说的很清楚。
5.7 Link errors when building libcurl on Windows!
You need to make sure that your project, and all the libraries (both static
and dynamic) that it links against, are compiled/linked against the same run
time library.
This is determined by the /MD, /ML, /MT (and their corresponding /M?d)
options to the command line compiler. /MD (linking against MSVCRT dll) seems
to be the most commonly used option.
When building an application that uses the static libcurl library, you must
add -DCURL_STATICLIB to your CFLAGS. Otherwise the linker will look for
dynamic import symbols. If you're using Visual Studio, you need to instead
add CURL_STATICLIB in the "Preprocessor Definitions" section.
If you get linker error like "unknown symbol __imp__curl_easy_init ..." you
have linked against the wrong (static) library. If you want to use the
libcurl.dll and import lib, you don't need any extra CFLAGS, but use one of
the import libraries below. These are the libraries produced by the various
lib/Makefile.* files:
Target: static lib. import lib for libcurl*.dll.
-----------------------------------------------------------
MingW: libcurl.a libcurldll.a
MSVC (release): libcurl.lib libcurl_imp.lib
MSVC (debug): libcurld.lib libcurld_imp.lib
Borland: libcurl.lib libcurl_imp.lib所以如果想要使用静态库，那就用 libcurl.a, 如果想用动态，就用 libcurldll.a。
但是注意：如果选择动态库，那么必须把 bin 文件夹下面的 libcurl-x64.dll 复制到 debug 或者 release 文件夹下面，dll 文件加上 dll.a 这两个文件组合起来才是完整的动态库。如果没有复制 dll 文件，程序运行不起来，会提示 异常退出。
参考: https://blog.csdn.net/qq_39989653/article/details/78947324
https://blog.csdn.net/trustguan/article/details/13607531
https://www.cnblogs.com/jiuzheer/p/9250704.html
在项目文件上右键，添加库 -> 外部库 -> 选择你想要的库。 注意，不要勾选 为 debug 版本添加 d 后缀。 qt 自动添加了三条语句。
unix|win32: LIBS += -L$$PWD/../../../../3rd-party/curl-7.77.0-win64-mingw/lib/ -llibcurl.dll
INCLUDEPATH += $$PWD/../../../../3rd-party/curl-7.77.0-win64-mingw/include
DEPENDPATH += $$PWD/../../../../3rd-party/curl-7.77.0-win64-mingw/include参考: https://www.jianshu.com/p/2350034fe380
DEPENDPATH 里面添加的会作为 make 中目标的依赖，一旦这个里面的内容改变了，相应的目标也会被重新编译。
增加DEPENDPATH设置
debug/main.o: ../../TestBoost/main.cpp def.h
$(CXX) -c $(CXXFLAGS) $(INCPATH) -o debug\main.o ..\..\TestBoost\main.cpp类似于上面的 main.cpp 和 def.h 如果改变了，都会导致 main.o 的重新编译。有些时候，修改了某些内容，结果没有重新编译，可能就是没有添加到依赖里面。
参考: https://blog.csdn.net/My__God/article/details/111517166
https://curl.se/windows/dl-7.73.0/
https://curl.se/windows/
参考：
https://github.com/curl/curl-for-win
上面准备做好了之后，可以进行简单的测试，直接在 mainwindow.cpp 中添加一个测试函数，然后在 MainWindow 的构造函数中调用即可。
void CurlTest()
{
CURL *curl = nullptr;
CURLcode res;
curl = curl_easy_init();
if (curl != nullptr) {
curl_easy_setopt(curl, CURLOPT_URL, "http://www.baidu.com");
/* example.com is redirected, so we tell libcurl to follow redirection */
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
/* Perform the request, res will get the return code */
res = curl_easy_perform(curl);
/* Check for errors */
if (res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
}
/* always cleanup */
curl_easy_cleanup(curl);
}
}参考: https://www.jianshu.com/p/6dc3ecec0245
在 libcurl 的下载页面靠下的位置有 OpenSSL 下载链接，下载解压就可以了。
在 pro 文件中增加:
unix|win32: LIBS += -L$$PWD/../../../../3rd-party/openssl-1.1.1k-win64-mingw/lib/ -llibcrypto.dll
INCLUDEPATH += $$PWD/../../../../3rd-party/openssl-1.1.1k-win64-mingw/include
DEPENDPATH += $$PWD/../../../../3rd-party/openssl-1.1.1k-win64-mingw/include把解压文件夹下面的 libcrypto-1_1-x64.dll 复制到 debug 文件夹下面即可。否则会出现 crash 的问题。
https://www.cnblogs.com/moodlxs/archive/2012/10/15/2724318.html
https://www.qtcentre.org/printthread.php?t=633&pp=20&page=1
#define#ifndef 的时候，这样用 <PROJECT>_<PATH>_<FILE>_H_。比如 foo/src/bar/baz.h 这个这样写 #ifndef FOO_BAR_BAZ_H_前置声明虽然可以节约时间，但是容易出问题，最好还是 include 头文件。
顺序是 相关头文件, C 库, C++ 库, 其他库的 .h, 本项目内的 .h. 比如：
namespace X {
inline namespace Y {
void foo();
} // namespace Y
} // namespace XX::Y::foo() 与 X::foo() 彼此可代替。内联命名空间主要用来保持跨版本的 ABI 兼容性。
namespace mynamespace {
} // namespace mynamespaceusing namespace foo;namespace baz = ::foo::bar::baz; 这种只能在源文件里面用，不能在头文件里面用，除非是内部命名空间，如下:// 在 .h 中使用别名缩短常用的命名空间
namespace librarian {
namespace impl { // 仅限内部使用
namespace sidetable = ::pipeline_diagnostics::sidetable;
} // namespace impl
inline void my_inline_function() {
// 限制在一个函数中的命名空间别名
namespace baz = ::foo::bar::baz;
...
}
} // namespace librarian在源文件中，匿名命名空间和静态变量产生的效果基本一致，这些变量只能在本文件中访问。匿名命名空间好处是不用在每条语句之前都增加 static.
namespace {
...
} // namespace使用静态成员函数或命名空间内的非成员函数, 尽量不要用裸的全局函数.
namespace myproject {
namespace foo_bar {
void Function1();
void Function2();
} // namespace foo_bar
} // namespace myproject如果你必须定义非成员函数, 又只是在 .cc 文件中使用它, 可使用匿名命名空间 或 static 链接关键字 (如 static int Foo() {...}) 限定其作用域.
构造函数不允许调用虚函数. 如果代码允许, 直接终止程序是一个合适的处理错误的方式. 否则, 考虑用 Init() 方法或工厂函数.
explicit 用来阻止隐式类型转换
在类型定义中, 类型转换运算符和单参数构造函数都应当用 explicit 进行标记. 一个例外是, 拷贝和移动构造函数不应当被标记为 explicit, 因为它们并不执行类型转换. 对于设计目的就是用于对其他类型进行透明包装的类来说, 隐式类型转换有时是必要且合适的. 这时应当联系项目组长并说明特殊情况.
见原文
仅当只有数据成员时使用 struct, 其它一概使用 class.
使用组合 (YuleFox 注: 这一点也是 GoF 在 <
所有继承必须是 public 的. 如果你想使用私有继承, 你应该替换成把基类的实例作为成员对象的方式.
不要过度使用实现继承. 组合常常更合适一些. 尽量做到只在 “是一个” (“is-a”, YuleFox 注: 其他 “has-a” 情况下请使用组合) 的情况下使用继承: 如果 Bar 的确 “是一种” Foo, Bar 才能继承 Foo.
必要的话, 析构函数声明为 virtual. 如果你的类有虚函数, 则析构函数也应该为虚函数.
对于可能被子类访问的成员函数, 不要过度使用 protected 关键字. 注意, 数据成员都必须是 私有的.
对于重载的虚函数或虚析构函数, 使用 override, 或 (较不常用的) final 关键字显式地进行标记. 较早 (早于 C++11) 的代码可能会使用 virtual 关键字作为不得已的选项. 因此, 在声明重载时, 请使用 override, final 或 virtual 的其中之一进行标记. 标记为 override 或 final 的析构函数如果不是对基类虚函数的重载的话, 编译会报错, 这有助于捕获常见的错误. 这些标记起到了文档的作用, 因为如果省略这些关键字, 代码阅读者不得不检查所有父类, 以判断该函数是否是虚函数.
真正需要用到多重实现继承的情况少之又少. 只在以下情况我们才允许多重继承: 最多只有一个基类是非抽象类; 其它基类都是以 Interface 为后缀的 纯接口类. 只有当所有父类除第一个外都是 纯接口类 时, 才允许使用多重继承. 为确保它们是纯接口, 这些类必须以 Interface 为后缀.
接口是指满足特定条件的类, 这些类以 Interface 为后缀 (不强制).
当一个类满足以下要求时, 称之为纯接口:
接口类不能被直接实例化, 因为它声明了纯虚函数. 为确保接口类的所有实现可被正确销毁, 必须为之声明虚析构函数 (作为上述第 1 条规则的特例, 析构函数不能是纯虚函数). 具体细节可参考 Stroustrup 的 The C++ Programming Language, 3rd edition 第 12.4 节.
除少数特定环境外, 不要重载运算符. 也不要创建用户定义字面量.
只有在意义明显, 不会出现奇怪的行为并且与对应的内建运算符的行为一致时才定义重载运算符. 例如, | 要作为位或或逻辑或来使用, 而不是作为 shell 中的管道.
只有对用户自己定义的类型重载运算符. 更准确地说, 将它们和它们所操作的类型定义在同一个头文件中, .cc 中和命名空间中. 这样做无论类型在哪里都能够使用定义的运算符, 并且最大程度上避免了多重定义的风险. 如果可能的话, 请避免将运算符定义为模板, 因为此时它们必须对任何模板参数都能够作用. 如果你定义了一个运算符, 请将其相关且有意义的运算符都进行定义, 并且保证这些定义的语义是一致的. 例如, 如果你重载了 <, 那么请将所有的比较运算符都进行重载, 并且保证对于同一组参数, < 和 > 不会同时返回 true.
建议不要将不进行修改的二元运算符定义为成员函数. 如果一个二元运算符被定义为类成员, 这时隐式转换会作用域右侧的参数却不会作用于左侧. 这时会出现 a < b 能够通过编译而 b < a 不能的情况, 这是很让人迷惑的.
不要为了避免重载操作符而走极端. 比如说, 应当定义 ==, =, 和 << 而不是 Equals(), CopyFrom() 和 PrintTo(). 反过来说, 不要只是为了满足函数库需要而去定义运算符重载. 比如说, 如果你的类型没有自然顺序, 而你要将它们存入 std::set 中, 最好还是定义一个自定义的比较运算符而不是重载 <.
不要重载 &&, ||, , 或一元运算符 &. 不要重载 operator"", 也就是说, 不要引入用户定义字面量.
将 所有 数据成员声明为 private, 除非是 static const 类型成员 (遵循 常量命名规则). 处于技术上的原因, 在使用 Google Test 时我们允许测试固件类中的数据成员为 protected.
将相似的声明放在一起, 将 public 部分放在最前.
类定义一般应以 public: 开始, 后跟 protected:, 最后是 private:. 省略空部分.
在各个部分中, 建议将类似的声明放在一起, 并且建议以如下的顺序: 类型 (包括 typedef, using 和嵌套的结构体与类), 常量, 工厂函数, 构造函数, 赋值运算符, 析构函数, 其它函数, 数据成员.
函数的参数顺序为: 输入参数在先, 后跟输出参数. C/C++ 中的函数参数或者是函数的输入, 或者是函数的输出, 或兼而有之. 输入参数通常是值参或 const 引用, 输出参数或输入/输出参数则一般为非 const 指针. 在排列参数顺序时, 将所有的输入参数置于输出参数之前. 特别要注意, 在加入新参数时不要因为它们是新参数就置于参数列表最后, 而是仍然要按照前述的规则, 即将新的输入参数也置于输出参数之前.
我们承认长函数有时是合理的, 因此并不硬性限制函数的长度. 如果函数超过 40 行, 可以思索一下能不能在不影响程序结构的前提下对其进行分割.
所有按引用传递的参数必须加上 const.
在 Google Code 是一个硬性约定: 输入参数是值参或 const 引用, 输出参数为指针. 输入参数可以是 const 指针, 但决不能是非 const 的引用参数, 除非特殊要求, 比如 swap().
若要使用函数重载, 则必须能让读者一看调用点就胸有成竹, 而不用花心思猜测调用的重载函数到底是哪一种. 这一规则也适用于构造函数.
如果打算重载一个函数, 可以试试改在函数名里加上参数信息. 例如, 用 AppendString() 和 AppendInt() 等, 而不是一口气重载多个 Append(). 如果重载函数的目的是为了支持不同数量的同一类型参数, 则优先考虑使用 std::vector 以便使用者可以用 列表初始化 指定参数.
只允许在非虚函数中使用缺省参数, 且必须保证缺省参数的值始终一致. 缺省参数与 函数重载 遵循同样的规则. 一般情况下建议使用函数重载, 尤其是在缺省函数带来的可读性提升不能弥补下文中所提到的缺点的情况下.
函数命名, 变量命名, 文件命名要有描述性; 少用缩写. 尽可能使用描述性的命名, 别心疼空间, 毕竟相比之下让代码易于新读者理解更重要. 不要用只有项目开发者能理解的缩写, 也不要通过砍掉几个字母来缩写单词.
int price_count_reader; // 无缩写
int num_errors; // "num" 是一个常见的写法
int num_dns_connections; // 人人都知道 "DNS" 是什么int n; // 毫无意义.
int nerr; // 含糊不清的缩写.
int n_comp_conns; // 含糊不清的缩写.
int wgc_connections; // 只有贵团队知道是什么意思.
int pc_reader; // "pc" 有太多可能的解释了.
int cstmr_id; // 删减了若干字母.注意, 一些特定的广为人知的缩写是允许的, 例如用 i 表示迭代变量和用 T 表示模板参数.
模板参数的命名应当遵循对应的分类: 类型模板参数应当遵循 类型命名 的规则, 而非类型模板应当遵循 变量命名 的规则.
文件名要全部小写, 可以包含下划线 () 或连字符 (-), 依照项目的约定. 如果没有约定, 那么 “” 更好.
C++ 文件要以 .cc 结尾, 头文件以 .h 结尾. 专门插入文本的文件则以 .inc 结尾, 参见 头文件自足.
不要使用已经存在于 /usr/include 下的文件名 (Yang.Y 注: 即编译器搜索系统头文件的路径), 如 db.h.
通常应尽量让文件名更加明确. http_server_logs.h 就比 logs.h 要好. 定义类时文件名一般成对出现, 如 foo_bar.h 和 foo_bar.cc, 对应于类 FooBar.
内联函数必须放在 .h 文件中. 如果内联函数比较短, 就直接放在 .h 中.
类型名称的每个单词首字母均大写, 不包含下划线: MyExcitingClass, MyExcitingEnum.
所有类型命名 —— 类, 结构体, 类型定义 (typedef), 枚举, 类型模板参数 —— 均使用相同约定, 即以大写字母开始, 每个单词首字母均大写, 不包含下划线. 例如:
// 类和结构体
class UrlTable { ...
class UrlTableTester { ...
struct UrlTableProperties { ...
// 类型定义
typedef hash_map<UrlTableProperties *, string> PropertiesMap;
// using 别名
using PropertiesMap = hash_map<UrlTableProperties *, string>;
// 枚举
enum UrlTableErrors { ...变量 (包括函数参数) 和数据成员名一律小写, 单词之间用下划线连接. 类的成员变量以下划线结尾, 但结构体的就不用, 如: a_local_variable, a_struct_data_member, a_class_datamember.
普通变量命名
string table_name; // 好 - 用下划线.
string tablename; // 好 - 全小写.
string tableName; // 差 - 混合大小写类数据成员 不管是静态的还是非静态的, 类数据成员都可以和普通变量一样, 但要接下划线.
class TableInfo {
...
private:
string table_name_; // 好 - 后加下划线.
string tablename_; // 好.
static Pool<TableInfo>* pool_; // 好.
};结构体变量 不管是静态的还是非静态的, 结构体数据成员都可以和普通变量一样, 不用像类那样接下划线:
struct UrlTableProperties {
string name;
int num_entries;
static Pool<UrlTableProperties>* pool;
};声明为 constexpr 或 const 的变量, 或在程序运行期间其值始终保持不变的, 命名时以 “k” 开头, 大小写混合. 例如:
const int kDaysInAWeek = 7;
所有具有静态存储类型的变量 (例如静态变量或全局变量, 参见 存储类型) 都应当以此方式命名. 对于其他存储类型的变量, 如自动变量等, 这条规则是可选的. 如果不采用这条规则, 就按照一般的变量命名规则.
常规函数使用大小写混合, 取值和设值函数则要求与变量名匹配: MyExcitingFunction(), MyExcitingMethod(), my_exciting_member_variable(), set_my_exciting_member_variable().
一般来说, 函数名的每个单词首字母大写 (即 “驼峰变量名” 或 “帕斯卡变量名”), 没有下划线. 对于首字母缩写的单词, 更倾向于将它们视作一个单词进行首字母大写 (例如, 写作 StartRpc() 而非 StartRPC()).
(同样的命名规则同时适用于类作用域与命名空间作用域的常量, 因为它们是作为 API 的一部分暴露对外的, 因此应当让它们看起来像是一个函数, 因为在这时, 它们实际上是一个对象而非函数的这一事实对外不过是一个无关紧要的实现细节.)
取值和设值函数的命名与变量一致. 一般来说它们的名称与实际的成员变量对应, 但并不强制要求. 例如 int count() 与 void set_count(int count).
命名空间以小写字母命名. 最高级命名空间的名字取决于项目名称. 要注意避免嵌套命名空间的名字之间和常见的顶级命名空间的名字之间发生冲突.
注意 不使用缩写作为名称 的规则同样适用于命名空间. 命名空间中的代码极少需要涉及命名空间的名称, 因此没有必要在命名空间中使用缩写.
要避免嵌套的命名空间与常见的顶级命名空间发生名称冲突. 由于名称查找规则的存在, 命名空间之间的冲突完全有可能导致编译失败. 尤其是, 不要创建嵌套的 std 命名空间. 建议使用更独特的项目标识符 (websearch::index, websearch::index_util) 而非常见的极易发生冲突的名称 (比如 websearch::util).
对于 internal 命名空间, 要当心加入到同一 internal 命名空间的代码之间发生冲突 (由于内部维护人员通常来自同一团队, 因此常有可能导致冲突). 在这种情况下, 请使用文件名以使得内部名称独一无二 (例如对于 frobber.h, 使用 websearch::index::frobber_internal).
枚举的命名应当和 常量 或 宏 一致: kEnumName 或是 ENUM_NAME.
单独的枚举值应该优先采用 常量 的命名方式. 但 宏 方式的命名也可以接受. 枚举名 UrlTableErrors (以及 AlternateUrlTableErrors) 是类型, 所以要用大小写混合的方式.
enum UrlTableErrors {
kOK = 0,
kErrorOutOfMemory,
kErrorMalformedInput,
};
enum AlternateUrlTableErrors {
OK = 0,
OUT_OF_MEMORY = 1,
MALFORMED_INPUT = 2,
};你并不打算 使用宏, 对吧? 如果你一定要用, 像这样命名: MY_MACRO_THAT_SCARES_SMALL_CHILDREN.
如果你命名的实体与已有 C/C++ 实体相似, 可参考现有命名策略.
bigopen(): 函数名, 参照 open() 的形式
uint: typedef
bigpos: struct 或 class, 参照 pos 的形式
sparse_hash_map: STL 型实体; 参照 STL 命名约定
LONGLONG_MAX: 常量, 如同 INT_MAX
https://zh-google-styleguide.readthedocs.io/en/latest/google-cpp-styleguide/naming/
类似于下面的写法
TENGINE = MASTER
#TENGINE = LITE
ifeq ($(TENGINE), MASTER)
CPPFLAGS += -DTENGINE_MT
else ifeq ($(TENGINE), LITE)
CPPFLAGS += -fsanitize=address -fsanitize=leak
endif参考: http://c.biancheng.net/view/7068.html
https://www.cnblogs.com/SoaringLee/p/10532151.html
=, :=, ?=, += 区别
=是最基本的赋值:=是覆盖之前的值?=是如果没有被赋值过就赋予等号后面的值+=是添加等号后面的值
= make会将整个makefile展开后，再决定变量的值。也就是说，变量的值将会是整个makefile中最后被指定的值。
x = foo
y = $(x) bar
x = xyzy的值将会是 xyz bar ，而不是 foo bar
:= 表示变量的值决定于它在makefile中的位置，而不是整个makefile展开后的最终值。
x := foo
y := $(x) bar
x := xyzy的值将会是 foo bar ，而不是 xyz bar 了。
参考: https://www.cnblogs.com/wanqieddy/archive/2011/09/21/2184257.html
有时候堆栈地址中有类似于 xxx.so + 0x1234 这样的，可以使用 objdump -DS xxx.so | grep -6 1234 这样来查看这个地址附近的代码，注意 0x1234 这样的地址结尾需要是手动调整为 4 的倍数，因为是 32bit 芯片。 或者也可以先把数据 dump 到一个 txt 文件中，然后在慢慢查看。
查看到相应的函数名称之后，可以使用 c++filt z4xyz 这样的方法，获得正常的 c++ 名称。
参考: https://blog.csdn.net/afei__/article/details/81181827
https://blog.csdn.net/ZZ7ZZ7ZZ/article/details/42238115
set verbose on 可以打开更多的信息打印。bt 来打印堆栈信息，bt full 打印堆栈的详细信息。 参考: https://www.it610.com/article/1279393691374469120.htm-g3 -ggdb 参考: https://blog.csdn.net/astrotycoon/article/details/8119048 使用 ldd your_exe 就可以查看具体内部链接了哪些动态库。
https://www.cnblogs.com/baiduboy/p/6830464.html
https://www.cnblogs.com/dongzhiquan/archive/2012/01/20/2328355.html
https://www.cnblogs.com/dongzhiquan/p/11939391.html
https://www.cnblogs.com/dongzhiquan/category/294212.html?page=2
https://documentation.suse.com/zh-cn/sled/15-SP2/html/SLED-all/cha-tuning-systemd-coredump.html
https://zhuanlan.zhihu.com/p/41153588
http://www.jinbuguo.com/systemd/systemd-coredump.html
转自: https://blog.csdn.net/veghlreywg/article/details/88556681
假设我们有一个函数
class Data
{
};
void func(Data && data)
{
}那么func能接收什么样的参数输入
Data data;
func(data); //[Error] cannot bind 'Data' lvalue to 'Data&&'data是个左值，不能绑定到右值上
Data data;
Data & d = data;
func(d); //[Error] cannot bind 'Data' lvalue to 'Data&&'d同样是个左值
都说const 引用和 右值引用有相似之处，尝试传递const 引用
Data data;
const Data & d = data;
func(d); // [Error] invalid initialization of reference of type
// 'Data&&' from expression of type 'const Data'传递匿名对象，匿名对象
func(Data()); // OK标准做法
Data data;
func(std::move(data));//OKmove一个左值引用
Data data;
Data & p = data;
func(std::move(p)); //OK直接声明一个右值引用，来做参数传递
Data p;
Data && p1 = std::move(p);
func(p1); // [Error] cannot bind 'Data' lvalue to 'Data&&'同样的错误，说明p1 还是左值
我们可以通过这个方式验证一下
void func(Data && data)
{
}
void func_1(Data && data)
{
func(data);//[Error] cannot bind 'Data' lvalue to 'Data&&'
}
Data data;
func_1(std::move(data));那么明明是个右值为什么，就变成左值了呢，这个时候就轮到 我们的std::forward出场了
Data p;
Data && p1 = std::move(p);
func(std::forward<Data>(p1)); // OK
void func_1(Data && data)
{
func(std::forward<Data>(data));
}
//这就是完美转发的意义所在把一个右值参数传递给const 引用类型
void func(const Data & data)
{
}
void func_1(Data && data)
{
func(data);//OK
}
Data data;
func_1(std::move(data));