-
命名空间namespace：在多人合作开发时，防止出现变量或函数的命名冲突
namespace A {
int a = 100;
namespace B
{
int a = 20;
}
}
int a = 200;
int main(int argc, char *argv[]) {
cout << "A::a =" << A::a << endl;
cout << "A::B::a =" << A::B::a << endl;
cout << "a =" << a << endl;
cout << "::a =" << ::a << endl;
using namespace A;
cout << "a =" << a << endl;
cout << "::a =" << ::a << endl;
int a = 30;
cout << "a =" << a << endl;
cout << "::a =" << ::a << endl;
using namespace A;
cout << "a =" << a << endl;
cout << "::a =" << ::a << endl;
}
-
关键字operator：用于重定义或重载大部分 C++ 内置的运算符。详情见此链接
-
关键字explicit的作用就是防止类构造函数的隐式自动转换。
class exp {
public:
explicit exp(int a) { temp = a; }
exp();
private:
int temp;
};
exp temp_exp = 10;
-
构造函数（未声明时编译器会自动声明）：默认构造函数、copy构造函数。当没有对象被定义，则使用copy assignment操作符。
class copy_class {
public:
copy_class();
copy_class(const copy_class &cc);
copy_class& operator=(const copy_class &cc);
};
copy_class cc1;
copy_class cc2(cc1);
copy_class cc3 = cc1;
cc2 = cc1;
-
构造函数使用成员初值列（member initialization list） 替代赋值动作，因为C++规定对象成员变量的初始化动作发生在进入构造函数本体之前。
class exp {
public:
explicit exp(int a, double b)
: temp(a),
num(b),
len(0) {
}
private:
int temp;
double num;
int len;
};
-
const成员函数：表示该成员函数不会修改成员变量；并且const对象只能调用const成员函数。
class exp {
public:
......
void print() const {
std::cout<<"const "<<temp<<" "<<num<<" "<<len<<std::endl;
}
void print(int a) {
len = a;
std::cout<<"no const "<<temp<<" "<<num<<" "<<len<<std::endl;
}
private:
int temp;
double num;
int len;
};
const exp const_exp();
const_exp.print();
exp no_const_exp();
no_const_exp.print(99);
-
虚析构函数：为了解决使用父类指针指向子类对象，但在释放子类对象的资源时，调用了父类析构函数；导致子类释放不完全，造成的内存泄漏问题。
-
try — throw — catch：异常是程序在执行期间产生的问题，异常处理提供了一种转移程序控制权的方式。设定一块区域由try监控，当出现异常时throw抛出异常，catch捕获抛出的异常并进行处理。
try {
throw "error test!";
} catch (const char *str) {
cerr<<str<<endl;
}
-
模板：模板是泛型编程的基础，泛型编程即以一种独立于任何特定类型的方式编写代码
-
函数模板，实际上是建立一个通用函数，它所用到的数据类型(包括返回值类型、形参类型、局部变量类型)可以不具体指定，而是用一个虚拟的类型来代替(实际上是用一个标识符来占位)，等发生函数调用时再根据传入的实参来逆推出真正的类型。 换个角度说，函数模板除了支持值的参数化，还支持类型的参数化。
template <typename type> ret-type func-name(parameter list)
{
}
template <typename T>
void Swap(T &a, T &b) {
T temp = a;
a = b;
b = temp;
}
int main(){
int n1 = 100, n2 = 200;
Swap(n1, n2);
float f1 = 12.5, f2 = 56.93;
Swap(f1, f2);
}
-
类模板
template <class T> class class_name {};
template <class T>
class my_stack {
public:
void push(T const &ele);
T* pop();
private:
vector<T> elems;
};
template <class T>
void my_stack<T>::push(T const &ele) {
elems.push_back(ele);
}
template <class T>
T* my_stack<T>::pop(){
if ( elems.empty() )
return NULL;
T* temp = &elems.back();
elems.pop_back();
return temp;
}
int main()
{
class my_stack<int> sta;
sta.push(10); sta.push(3);
cout<<*sta.pop()<<endl; cout<<*sta.pop()<<endl;
class my_stack<string> str;
string str1 = "hello"; string str2 = "world";
str.push(str1); str.push(str2);
cout<<*str.pop()<<endl; cout<<*str.pop()<<endl;
}
-
#起到将内容双引号成字符串的作用，## 起到连接连接参数的作用
#define TRAN_STR(x) (#x)
#define CONNECT(x, y) (x##y)
string YourName = "what is you name";
cout<<TRAN_STR(tran to str)<<endl;
cout<<CONNECT(Your, Name)<<endl;
-
多线程：pthread_create (thread, attr, start_routine, arg)
void* say_hello(void* args) {
string str = *((string*)args);
cout << str << endl;
return 0;
}
int main()
{
string str = "hello world";
pthread_t th;
if ( pthread_create(&th, NULL, say_hello, &str) )
cout<<"create thread error"<<endl;
pthread_exit(NULL);
}
-
类protected成员：防止继承后的基类private成员无法访问，于是有了protected，集合了public成员(对派生类) 和 private成员(对外部访问) 的特点。
-
static类成员
-
结构体/联合体/类内存对齐原则
-
设定第一个成员在offset为0的地方，后续的基本数据类型的起始位置是其大小的整数倍，后续结构体/联合体的起始位置是其最大基本数据类型大小的整数倍。
-
收尾时，总的数据大小必须是其中最大基本数据类型的整数倍（子结构中的基本数据类型也包括）。
class exp {
public:
static const int CONST_VAL = 100;
exp(int a);
exp();
~exp();
private:
int temp;
double num;
int len;
};
union example {
int a[5];
char b;
double c;
};
struct example2 {
int a[4];
union example e1;
char b;
union example e2;
int16_t c;
};
-
引用
- 引用变量是一个别名，也就是说，它是某个已存在变量的另一个名字
- 与指针区别：int &a = b; 相当于int * const a = &b;
- 不存在空引用。引用必须连接到一块合法的内存。
- 一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。
- 引用必须在创建时被初始化。指针可以在任何时间被初始化。
- 形参是引用变量，调用函数时，形参(引用变量)指向实参变量单元。这种通过形参引用的方式可以改变实参的值。
-
友元函数/友元类：可以直接访问类内所有对象，为了实现一些特定的操作，打破了类的封装特性。
class Box {
private:
double width;
public:
friend void printWidth(Box box);
friend class BigBox;
void setWidth(double wid) { width = wid; }
};
class BigBox {
public :
void Print(int width, Box &box) {
box.setWidth(width);
cout << "Width of box : " << box.width << endl;
}
};
void printWidth(Box box)
{
cout << "Width of box : " << box.width << endl;
}
int main()
{
Box box;
BigBox big;
box.setWidth(10.0);
printWidth(box);
big.Print(20, box);
return 0;
}