C++的历史与演化
C++起先是在C语言上面的一种拓展，后来演化到现在，已经是一门独立且备受瞩目的语言了。
语言关系图: B -> C -> C++(new C -> C with class -> C++
演化路线图: C++98 -> C++03 -> C++11 -> C++14
C++的几种模式
C++本身被视作一个语言的联邦，本身是一种多范型的语言。学好C++，需要了解一下的几种C++的常用范型。
- Clean C
- Object-Oriented C++
- Template C++
- STL
C++原本的翻译作为C plus plus， 第一版语言本身可以被称作为C with Class。 对于Class这个名词而言，C++有可以区分为OBP && OOP。
OBP本身是利用了C++对Data Resource的一种封装，这里一般就是单个Class而已，很少与其他Class发生较多的交互。而OOP本身更多的使用了继承与多态，而且OOP更加注重于Class与Class之间的关系。Class与Class之间的关系有继承(inheritance)，复合(composition)和委托(delegation)。
C++代码的基本结构
C++的代码一般分为声明部分 && 实现部分。
声明部分一般存放在.h .hpp结尾的文件中。 实现部分一般存放在.cc .cpp .C结尾的文件中。
为什么这里要区分声明 && 实现呢。因为一个项目不可能只有一个文件，一般一个工程是多人协作式的。首先单个文件无法多人进行编辑。第二，如果每个人负责项目的一个模块，一个只要关心自己的部分和他人与自己相关的部分了。如果实现与声明相分离，相关的人员只需要在开发的时候约定声明的部分，可以在开发过程中不关心实现，到最后进行代码的集成测试就可以了。
C++的声明文件为了防止多次包含有两种技巧。一种是防御式声明(ifndef), 一种使用#pragma once
- 防御式声明
// hello.h
#ifndef HELLO_H_
#define HELLO_H_
#endif // HELLO_H_
- pragma
// hello.h
#pragma once
C++ Class
一般认为C++本身包括了C语言部分即Clean C。C语言的声明 && 控制，C++基本与其类似。
C++的Class一般包含了构造与析构部分。构造是用来初始化一个对象，析构是对象生命周期结束后告诉编译器如何删除一个对象。构造函数和析构函数属于特殊的函数。这两种函数都是没有返回值的。
C++的对象如果名称叫做complex，那么构造函数就是complex(...), ...表示参数列表, 这里可以看出complex是可以有多个的，本身可以被重载。 析构函数就是~complex,析构函数是没有参数列表的。C++如果不声明构造函数或者析构函数的话。编译器本身会给合成一个构造或者析构函数。合成的构造函数是没有参数列表的。如果一个类中含有指针，最好自定义析构函数，否则合成的析构函数不会delete指针所对应的对象。
class complex {
public:
complex(int re, int im); // 构造函数
~complex(); // 析构函数
private:
int re_, im_;
};
C++本身也有权限控制比如public， private, protected。
public表示在类以外也能被访问，而private表示只能在类中被访问。protected表示在被继承的类中能够被直接访问。class默认是private类型的，struct 默认是public类型的。这个是class/struct声明的两者的根本区别。
这里有一个特点如果构造函数在private区域可以被用来实现单例模式。
// singleton
#include
using namespace std;
class Singleton {
Singleton() {}
static Singleton *instance;
public:
~Singleton() { cout << "Singleton dtor" << endl; }
struct GC {
~GC() { if(instance) { cout << "Delete Singleton" << endl; delete instance; } }
};
private:
static GC gc;
public:
static Singleton *Instance() {
if (!instance) {
instance = new Singleton;
}
return instance;
}
};
Singleton *Singleton::instance = NULL;
Singleton::GC gc;
int main()
{
Singleton *s = Singleton::Instance();
// delete t;
return 0;
}
在C++中一个member function也可以是const的，这里表示this指针是const，所以不能修改类实例的成员变量的值。const的类实例变量只能调用const 方法
class complex {
public:
complex(double r = 0, double i = 0) : re(r), im(i) {}
complex &operator+=(const complex &);
complex &operator-=(const complex &);
complex &operator*=(const complex &);
complex &operator/=(const complex &);
double real() const { return re; }
double imag() const { return im; }
private:
double re, im;
friend complex &__doapl(complex *, const complex &);
friend complex &__doami(complex *, const complex &);
friend complex &__doaml(complex *, const complex &);
};
{
const complex c(1, 2);
cout << c.real() << endl;
}
C++的函数传值
- pass by value
通过值来传递给调用的函数，此时在调用的函数修改了值，原先的变量的值还是不会改变
void fun(int a)
{
a += 1;
}
{
int a = 10;
fun(a);
cout << a << endl; // 10 not 11
}
- pass by reference/pointer
通过引用来传值，这里如果在调用的函数中修改了值，原先的值也会被修改。reference 编译器的实现实际上是一个const pointer。
void fun(int a)
{
a += 1;
}
{
int a = 10;
fun(a);
cout << a << endl; // 11 not 10
}
Operator Overloading
C++自定义类型的一些operator是可以被重载的，比如+，+=，++，但是基本类型的是不可以的，这个会引起底层的混乱。
op any of the following 38 operators:+ - * / % ˆ & | ~ ! = < > += -= *= /= %= ˆ= &= |= << >> >>= <<= == != <= >= && || ++ -- , ->* -> ( ) [ ]
1) overloaded operator;
2) [user-defined conversion function](http://en.cppreference.com/w/cpp/language/cast_operator);
3) [allocation function](http://en.cppreference.com/w/cpp/memory/new/operator_new);
4) [deallocation function](http://en.cppreference.com/w/cpp/memory/new/operator_delete);
5) [user-defined literal](http://en.cppreference.com/w/cpp/language/user_literal).
Synatax
operator op (1)
operator type (2)
operator new
operator new [] (3)
operator delete
operator delete [] (4)
operator "" suffix-identifier (5) (since C++11)
| Expression | As member function | As non-member function | Example |
|---|---|---|---|
| @a | (a).operator@ ( ) | operator@ (a) | !std::cin calls std::cin.operator!() |
| a@b | (a).operator@ (b) | operator@ (a, b) | std::cout << 42 calls std::cout.operator<<(42) |
| a=b | (a).operator= (b) | cannot be non-member | std::string s; s = "abc"; calls s.operator=("abc") |
| a(b...) | (a).operator()(b...) | cannot be non-member | std::random_device r; auto n = r(); calls r.operator()() |
| a[b] | (a).operator | cannot be non-member | std::map |
| a-> | (a).operator-> ( ) | cannot be non-member | auto p = std::make_unique |
| a@ | (a).operator@ (0) | operator@ (a, 0) | std::vector |
in this table, @ is a placeholder representing all matching operators: all prefix operators in @a, all postfix operators other than -> in a@, all infix operators other than = in a@b
C++临时变量
C++的临时变量的产生一般和函数调用相关，一个调用如果没有被一个左值接受，那么就可产生一个临时变量，这个变量的生命周期是这条语句。这种变量在functor , 链式调用 和 一些使用到RAII的手法中经常会被使用到(比如Logger class)。临时变量实际上和左值，右值有着密切的关系，以后有机会再详细说明。
#include
using namespace std;
class Temp {
public:
Temp(int t) : t_(t) {}
~Temp() { cout << t_ << endl; }
private:
int t_;
};
int main()
{
cout << "---------- Begin ----------" << endl;
Temp(1); // 1
Temp(2); // 2
cout << "---------- End ----------" << endl;
return 0;
}
/*
output:
---------- Begin ----------
1
2
---------- End ----------
*/
// 这里1，2在End之前被打印出来，可以看出临时变量的声明周期就只有单条语句
总结
在这次课程中，我对对过去的知识做了一个完整的梳理与总结。感觉还是很不错的。以后还需要认真学习。