最近准备重新学习学习C++，因为之前也都是上课学习，其实很多细节自己还是没有掌握地很好，现在时间比较充裕，乘着这个窗口期赶紧再充实一下自己。这系列的文章既是每周的总结也是希望跟读者们共同进步，相互学习。
这篇文章并不是讲C++的语法，而是C++学习的预热。内容看起来很杂，其实是一些自己感觉很熟的东西中容易忽略的地方。主要是建立学习C++的好奇与兴趣。正如某位大佬所说：“技术领域并不缺少神奇，只是缺少发现神奇的眼睛。”
主要内容包括：c++工程开发规范；编译链接的具体过程；如何在c++工程中引入第三方模块以及预处理。
说明：部分内容源自自己购买的付费课程，若有侵权，请联系删除。
<面向对象>
对于最开始的一段代码：
#include<iostream>
using namespace std;
int main(){
cout<<"hello world"<<endl;
return 0;
}
其中，cout到底是什么东西呢?
->实际上，cout在c++中是一个预定义的对象。
<运算符重载>
目的：通过运算符重载可以输出自定义的对象，让不同类型的对象使用更加方便，符合编码逻辑
#include<iostream>
using namespace std;
class Point{
public:
Point(int x,int y):x(x),y(y){}
int x,y;
};
//重载运算符
ostream &operator<<(ostream &out, const Point &p){
out<<"("<<p.x<<","<<p.y<<")";
return out;
}
int main(){
Point a(3,4);
cout<<"hello world"<<endl;
cout<<a<<endl;
return 0;
}
-->
hello world
(3,4)
其中，思考一下两个问题：
-
operator<< 返回的是左值引用。但什么是左值引用呢？
可以实现连续赋值的操作，如==，+=，<<等。这里就是说，cout<<a之后仍返回一个ostream的实例。
更简单的解释是：下面这个例子
int a=5,b=7; (a=b)=10; //result: a=10, b=7具体过程：b先赋值给a，返回一个int对象的引用（a的引用），然后再将10赋值给这个引用，所以最终才会有这个答案。若（a=b）返回的不是左值引用，而仅仅是一个值，那么int值=10就编译不通过了（报错为：error: left value required as left operand of assignment）。
小结：连续运算符的重载应返回左值引用
-
为什么第二个参数要为const类型？
- 不希望对类成员变量进行修改。
- 加上const，对于const和非const的实参，函数都能接受。但不加的话，就只能接受非const的实参。编译不能通过（报错为：error: no match for ‘operator<<’ (operand types are ‘std::ostream {aka std::basic_ostream}’ and ‘const Point’)）
同时补充一下，使用引用&Point 是因为 可以避免在函数调用时对实参的一次拷贝，提高了效率。
<工程开发规范>
对于<运算符重载>部分的代码：
存在以下问题：
- 没有将类的声明与定义分离
- 暴露了类的成员变量
- 命名空间的使用，不清楚到底引入了多少符号！
修改如下：
#include<iostream>
//using namespace std;
using std::cout;
using std::endl;
using std::ostream;
class Point{
public:
Point(int x,int y);
friend ostream &operator<<(ostream &out,const Point &p); // 若私有变量需要被外部函数使用，那么可以使用友元函数。
private: // 保护类的成员变量
int x,y;
};
Point::Point(int x,int y):x(x),y(y){} // 分离类的声明与定义
//重载运算符
ostream &operator<<(ostream &out, const Point &p){
out<<"("<<p.x<<","<<p.y<<")";
return out;
}
int main(){
Point a(3,4);
cout<<"hello world"<<endl;
cout<<a<<endl;
return 0;
}
但是注意，类的成员变量若是私有，外部需要访问就需要将 使用了这个私有成员变量的函数 声明为友元函数。
<c++为什么难学>
有以下几个原因：
-
c++语法难学，多样复杂
-
“技术想象力”要求高（用“编程范式”来举例了，如：面向过程，面向对象，泛型编程，函数式编程。即设计代码的思想），来源于夯实的基础知识。为什么会看不懂开源代码？就是由于基础知识的匮乏导致的技术想象力有限。
技术想象力的例子，以c++中实现加法为例：
// 面向过程 int add1(int a,int b){ return a+b; } // 面向对象 class ADD{ public: int operator()(int a,int b){ return a+b; } }; // 泛型编程 template<typename T,typename U> auto add3(T a, U b) -> decltype(a+b){ return a+b; } // 函数式编程 auto add4 = [](int a,int b) -> int { return a+b; }; int main(){ ADD add2; cout<<add1(3,4)<<endl; cout<<add2(3,4)<<endl; cout<<add3(3,4)<<endl; cout<<add4(3,4)<<endl; return 0; } // main中，看似使用的一样，但是背后实现完全不同！其实，为什么c++语法特性多，难学，是因为c++要同时支持4种编程范式。
-
c++背后承载的体系特别大。不仅仅是c++语言本身，除此之外，c++跟底层系统的联系，和网络的联系，所透露出算法数据结构的思想，不同的编程范式等。一个真正掌握c++开发的程序员，背后的这套体系极其夯实庞大！
你是这样的【盲人】工程师吗？
C源码变成可执行文件的重点的两个过程（一共有6个过程）：
对象文件中，存放的是“定义”
多个C源码被编译为多个对象文件，然后将多个对象文件链接成一个可执行文件。
<声明与定义>
- 声明：相当于一个说明的作用
- 定义：表示具体的实现过程
// 声明
int add(int a, int b);
// 定义
int add(int a,int b){
return a+b;
}
对于对象文件是什么感到好奇吗？
<编译阶段>
编译阶段的主要目的：语法检查。即确保c源码没有语法错误，能生成对象文件。
只执行编译的命令：
g++ -c main.cpp
查看对象文件main.o中到底是什么东西：
nm -C main.o
得到以下的结果：
其中，前面有一串数字以及T字母的 这些方法是当前文件中定义的；没有数字的 表示那些方法的定义是在外部进行查找的。
思考：那些需要外部查找定义的函数是如何被找到的呢？
注意：编译阶段不需要知道所声明函数的定义
<链接阶段>
链接阶段的主要目的：将多个对象文件拼接在一起。把对象文件中需要外部查找的方法与其具体的定义链接起来。
相当于，你有病（需要外部查找的方法），我有药（方法的定义），我们之间匹配上了。
举例：
（1）main.cpp --> main.o
#include<iostream>
using namespace std;
int add(int a,int b);
int main(){
cout<<"add(3,4)="<<add(3,4)<<endl;
return 0;
}
// main.o的部分内容
U add(int, int)
0000000000000000 T main
（2）add.cpp --> add.o
int add(int a,int b){
return a+b;
}
// add.o中的内容
0000000000000000 T add(int, int)
接着将这两个对象文件连接在一起，就可以形成一个完整的可执行程序。
g++ main.o add.o
然后执行这个可执行文件
./a.out
-----result------
add(3,4)=7
<小结>
- 编译阶段主要在做 语法检查， 而链接阶段主要在做 定义匹配。
- 声明作用于编译阶段，帮助源程序通过编译（编译期间出现的错误主要有：符号未定义/找不到，语法错误等）；定义作用在链接阶段，帮助对象文件完成定义的匹配（链接阶段出现的错误主要有：定义不存在或者定义冲突）
- 声明主要放在头文件中，定义主要放在源文件中
google测试框架
重点：学习如何在c/c++工程中引入第三方功能模块
我们在编译阶段只需要第三方模块的声明（在头文件.h中），在链接阶段，我们需要第三方模块的定义（静态链接库.a文件）
googletest提供的是cmake方法进行编译，那么新建build文件夹并对googletest模块进行编译，得到如下结果：
zzmine@ubuntu:~/myLibs/googletest/build$cmake ../
zzmine@ubuntu:~/myLibs/googletest/build$ make
Scanning dependencies of target gtest
[ 12%] Building CXX object googletest/CMakeFiles/gtest.dir/src/gtest-all.cc.o
[ 25%] Linking CXX static library ../lib/libgtest.a
Scanning dependencies of target gmock
[ 37%] Building CXX object googlemock/CMakeFiles/gmock.dir/src/gmock-all.cc.o
[ 50%] Linking CXX static library ../lib/libgmock.a
Scanning dependencies of target gmock_main
[ 62%] Building CXX object googlemock/CMakeFiles/gmock_main.dir/src/gmock_main.cc.o
[ 75%] Linking CXX static library ../lib/libgmock_main.a
[ 75%] Built target gmock_main
Scanning dependencies of target gtest_main
[ 87%] Building CXX object googletest/CMakeFiles/gtest_main.dir/src/gtest_main.cc.o
[100%] Linking CXX static library ../lib/libgtest_main.a
注意这里生成了4个.a文件，并且有一个lib文件夹，这个就是第三方模块googletest中方法的定义！
然后在xxx/googletest/googletest/ 中可以找到include文件，这就是第三方模块googletest中方法的声明！
接着就可以使用googletest编写C++程序了：
#include<iostream>
#include<gtest/gtest.h>
using namespace std;
int add(int a,int b){
return a+b;
}
TEST(test,add1){
EXPECT_EQ(add(3,4),8);
EXPECT_EQ(add(3,4),7);
}
TEST(test,add2){
EXPECT_LT(add(3,4),7);
EXPECT_LT(add(3,4),8);
}
int main(){
cout<<"add(3,4)="<<add(3,4)<<endl;
return RUN_ALL_TESTS();
}
但是，在执行编译过程时，发生以下报错：
zzmine@ubuntu:~/CPractice$ g++ -c main.cpp
main.cpp:2:9: fatal error: gtest/gtest.h: No such file or directory
#include<gtest/gtest.h>
^~~~~~~~~~~~~~~
compilation terminated.
说明，其实在默认的头文件搜索路径中，没有包括googletest的include文件夹。
所以需要告诉g++编译器，在编译搜索目录时需要加上googletest的include路径。执行（这里我把googletest的include路径拷贝到当前目录中了）：
g++ -I./include -c main.cpp
完成了编译过程，此时在当前目录中生成了一个main.o文件。用nm -C main.o查看对象文件内容，发现有大量的外部符号链接。
接下来进行链接过程，将main.o与之前生成的googletest静态链接库文件进行链接。
g++ -L./lib main.o -lgtest
最后，执行可执行文件 ./a.out 获得想要的输出结果。
预处理
C++源文件通过预处理得到待编译源码，待编译源码决定了可执行文件的功能。
所有预处理命令都是以#开头，其中宏定义是预处理家族中的一员，宏做的事情就是简单的替换。
<宏定义>
-
定义符号常量
#define PI 3.1415926 #define MAX_N 10000 -
定义表达式
#define S(a,b) a*b -
定义代码段：注意，每行后面要加\ 表示连接，因为预处理命令只能写在一行
#define P(a) { \ printf("%d\n",a); \ }
备注：#include 表示将后面库文件的内容添加到当前文件中。
举例：define.cpp
#include<iostream>
using namespace std;
#define PI 3.1415926
int main(){
printf("%lf\n",2*PI);
return 0;
}
可以执行一下命令来查看待编译源码的内容：
g++ -E define.cpp
也可以通过重定向文件输出到某个文件中进行查看：
g++ -E define.cpp > output.cpp
发现主函数部分被替换成了如下的代码：
// ... 上面省略了很多产生的内容
int main(){
printf("%lf\n",2*3.1415926);
return 0;
}
需要特别注意的是，可执行文件的功能完全取决于待编译源码！
可以举出下面的一些例子：
#define S(a,b) a*b
S(3,4) ---> 3*4=12
S(3+9,4) ---> 3+9*4=39
int n = 5;
S(int,p)=&n; ---> int*p = &n;
<预定义的宏>
| 宏 | 说明 |
|---|---|
| __ DATE __ | 日期：Mmm dd yyyy |
| __ TIME __ | 时间：hh:mm:ss |
| __ LINE __ | 行号 |
| __ FILE __ | 文件名 |
| __ FUNC __ | 函数名/非标准 |
| __ PRETTY_FUNCTION __ | 更详细的函数信息 |
反思
通过这种探索式的学习，自己发现其实C++中有很多有趣的内容，而这些在之前的课程学习中完全被忽略掉了，当时的我只是很功利地去模拟书上的代码，却很少静下心来领略编程的艺术。
同时，我在重学C++的过程中，全程使用的是Linux平台的g++编译器以及vim编辑器，而没有选择更加“方便”的IDE。在学习的过程中，我对c++文件从文本到可执行文件的过程有了更深的理解。我明显地感觉到自己对C++的理解更加深刻了，其实这种感觉也说不上来是什么样子，大概就是代码打起来手比较熟，报错啥的完全不慌哈哈哈哈哈。印象最深刻的就是可执行文件的功能其实完全取决于预编译源码，而并不是自己写的源代码。感觉正确的编程学习方式还是要基于原理，然后大规模开发需要提升效率再使用IDE。
最后，这并不是一周所学的全部内容，只是这些都是C++预热的部分，而且全放在一篇文章会显得很臃肿，所以其余内容将会在后续发布。
若有任何疑问，欢迎交流！
637
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
