【转】C++知识点汇总

变量与函数
 
变量声明：
extern int i;
函数声明：
extern float f(float);
float f(float); //extern在此不是必须的
float f(float a); //声明中起作用的只有类型，与变量名无关
变量定义：（变量在第一次定义时被声明）
int i;
函数定义：（有函数体的函数声明就成了函数定义）
float f(float a) { return a + 1; }
有了声明就必须有定义，有了定义声明就可以不要，因为定义包含了声明。
 
函数在定义时可以有未命名的参数。比如某参数在函数体中未被使用，则删去此参数的名称后编译时就不会有变量未使用的警告。
 
func()在C++中表示没有参数的函数，而在C中表示不确定的参数（这种情况下就会忽略类型检查）。func(void)在C和C++中都表示没有参数的函数。
 
C++中可以在程序的任何地方定义变量，但有些格式是不允许的。比如：
for (int i = 0, int j = 0; ...; ...;) // 只允许在for中定义一个变量
while ((char c = cin.get()) != 'q') // 定义变量时不允许使用括号
 
局部变量都是auto的，因此没有必要显式地使用auto来修饰局部变量。
 
只能在块中定义register变量。register变量不能被取址。（不推荐使用）
 
定义为static的变量可以在块外继续存在，但却只能在块内被访问。比如在函数中定义时可以像全局变量一样维持原有的值，但不像全局变量可以被程序的其他部分修改。（静态存储）
 
static修饰全局变量或函数时表示该变量或函数只在当前文件中有效（内部联接）。（静态可见性）
 
用extern修饰的变量或函数的定义可以在其他文件中出现（外部联接）。全局变量和函数默认都是extern的（C++中的const除外）。
 
const修饰的变量在C++中只在文件内部有效（内部联接），若要使它在其他文件中有效需要加上extern修饰。而在C中的const默认是extern的，因此不同文件中不允许有重名的const。
 
使用volatile修饰的变量会在每次需要的时候被重新读取，编译器不会对其加优化。
 
在成员函数里要使用同名的全局变量或函数时，在全局的函数名或变量名前加::，表示全局的域。
 
 
 
结构和数组
 
被嵌套的结构不能访问嵌套其的结构私有成员，必须先声明被嵌套的结构，再声明其为friend，最后定义此结构。
 
对象在域结束后会被自动销毁。析构函数会被自动调用，即使是使用goto语句跳出域也一样。但是使用C标准库中的setjmp()和longjmp()跳出时析构函数不会被调用。
 
如果给定一个数组的初始值小于数组的大小，数组中剩余的元素会被初始化为0。如：
int b[6] = {0};
但只有数组定义没有初始值时就没有这种效果。
 
结构体的初始化也一样：
struct X {
  int i;
  float f;
  char c;
};
X x1 = { 1, 2.2, 'c' };
但当结构体中有构造函数时，必须通过构造函数初始化：
struct Y {
  float f;
  int i;
  Y(int a);
};
Y y1[] = { Y(1), Y(2), Y(3) };
 
union中也能定义访问控制、成员函数和构造/析构函数，但是union不能被继承。
 
也可以定义匿名的union，这时访问union中的成员不需要加上域标识符。
 
 
 
const
 
const int* u;和int const* v都表示指向常量的指针。int* const w;才表示指针常量。即const在*左边表示指向常量的指针，const在*右边表示指针常量。也可以理解为const只修饰它左边的东西。
 
字符串数组应该是常量，因此像char* cp = "howdy";这样的写法按理不能修改字符串的内容，而应该写成char cp[] = "howdy";。但为了与C代码兼容，编译器通常会容许这个错误。
 
只有不是const的返回值能被用作lvalue，因此若不希望函数返回的对象被用作lvalue，可以用const来修饰。
 
在表达式或函数求值的过程中编译器生成的临时对象都是const的。因此如果函数要以引用方式接受临时对象作为参数时，参数引用也需要用const修饰。
 
类中的const只表示在初始化后不能改变，需要在构造函数初始化列表中初始化。如：
Fred::Fred(int sz) : size(sz) {}
这就使得const能在构造函数被定义时就被初始化。对于非const的类型的初始化也可以这样进行。对于内置类型的初始化也可以用这种像是调用构造函数的形式。
 
类中以static修饰的const变量表示被这个类的所有对象共用。必须在定义时就被初始化。在旧的编译器下，一般使用enum来代替。如static const int size = 100;就用enum { size = 100 };代替。
 
被声明为const的对象只能调用其为const的成员函数。声明为const的成员函数中不能对对象的内容进行修改或调用非const的成员函数。定义时const放在函数参数列表之后（放在前面会与const的返回值混淆）。
 
非const的对象也能调用const的成员函数。因此把不会改变对象内容的成员函数定义为const的就能具有最大的通用性。构造函数和析构函数不能是const的。
 
在const的成员函数中修改对象的成员：
1、将this转换为普通的指针（const成员函数中的this是const指针），就能通过其来改变对象的成员，如：
((Y*)this)->i++;
或
(const_cast<Y*>(this))->i++;
2、以mutable修饰的成员能在const的成员函数中被修改。
 
 
 
关于预处理
 
#define的常量用const取代，宏用inline函数取代。
 
在类定义中定义的函数自动为内联函数。也可以使用inline修饰函数使其成为内联的。inline只有在函数定义时才会发挥作用。因此头文件中的内联函数都是有函数体的。inline的函数也是内部联接的。
friend的函数也可以是inline的。
 
inline只是对编译器的优化提示，编译器不一定会对所有的inline进行内联。
 
不可替代的预处理功能：
字符串化（#，将标识符转化为字符串）：#define DEBUG(x) cout << #x " = " << x << endl
记号粘贴（##，连接两个标识符形成一个新的标识符）：#define FIELD(a) char* a##_string; int a##_size
 
 
 
static
 
编译器保证对static的内置类型赋初值。对于static的对象调用其默认的构造函数。
 
static对象的析构函数会在main()函数结束或调用exit()时被自动调用。因此在static对象的析构函数中调用exit()可能会导致递归调用。调用abort()时不会自动调用static对象的析构函数。
 
全局的对象是static的。因此全局对象的构造和析构函数可以用来在进入main()之前和退出main()之后完成一些工作。
 
对于全局的对象来说，因为其本身是静态存储的，因此使用static修饰的效果只是使其变为内部联接。
 
静态数据成员的定义：
class A {
  static int i;
public:
  //...
};
int A::i = 1;
只有static const的整型才能在类内部被初始化，其他类型都必须在外部（文件域中）被初始化。因此本地类（在函数中定义的类）中不能定义静态成员。
 
static的成员函数在类中定义。为所有该类的对象共用，调用时可以直接使用类名::函数名。
 
static的成员函数只能访问static的成员，因为static的成员没有this。
 
static初始化的依赖关系（最好避免）。可参考iostream的实现（cin、cout和cerr都是在不同文件中的static对象）或另一种（居然无名！）方法。
 
 
 
namespace
 
#include <iostream.h>
意味着
#include <iostream>
using namespace std;
因为在标准化之前不存在名字空间，.h中的所有内容都是暴露的
 
namespace定义只能出现在全局域或另一个namespace中。定义的{}后没有分号。可以跨越多个文件定义（不算重复定义）。也可以定义别名。如：
namespace Bob = BobsSuperDuperLibrary;
 
每个编译单元都有一个未命名的namespace。通过将变量放入这个namespace中就可以不必将它们声明为static的（内部联接）。C++中要达到文件内的静态就使用这种方法。
 
类中声明的友元也会进入这个类所在的namespace。
 
using namespace只在当前域内有效（将namespace中的所有名称注入当前域）。using namespace中引入的名称可以被覆盖。
 
联接方式。比如需要在C++中调用C的库中的函数：
extern "C" float f(int a, char b);
否则的话联接程序可能无法解析函数调用。通常编译器都会自动处理这种情况。
 
 
 
引用和指针
 
引用必须在创建时被初始化为引用某一个变量，并且一旦在初始化后就不能再改变被引用的对象。
 
函数返回引用时要注意引用的对象不能在函数返回后就不存在了，比如函数内部的变量。
 
拷贝构造函数接受的是本类的引用。定义拷贝构造函数就必须定义构造函数。
 
通过声明一个private的拷贝构造函数可以防止对象被传值。
 
指向特定类中成员的指针：
声明：
int ObjectClass::*pointerToMember;
初始化：
int ObjectClass::*pointerToMember = &ObjectClass::a;
使用：
objectPointer->*pointerToMember = 47;
object.*pointerToMember = 47;
对于成员函数也适用
 
 
 
运算符重载
 
重载的运算符必须接受至少一个自定义类型。接受的参数都为内置类型的运算符无法被重载。
 
运算符作为类的成员函数被重载时，类的对象就作为第一个参数。注意此时函数的返回方式。
 
重载++a会调用operator++(a)，重载a++会调用operator++(a, int)，其中第二个int参数是不会被用到的，只是用来区分前缀和后缀调用。--的重载也是一样。
 
=和[]只能作为成员函数被重载。()只能作为成员函数被重载，可以带任意多个参数。（若可以不作为成员函数被重载，则对于内置类型的运算就可以被重载，这是没有意义的）
 
->和->*也只能作为成员函数被重载，但对返回值有一定的限制。
 
.和.*不能被重载
 
返回值优化：
Integer tmp(left.i + right.i);
return tmp;
这样编译器需要三步才能完成（构造，拷贝，析构），而
return Integer(left.i + right.i);
则只需要一步
 
重载时作为成员或非成员函数的选择：
所有的一元运算符 推荐作为成员
= () [] -> ->*  必须作为成员
+= -= /= *= ^=
&= |= %= >>= <<= 推荐作为成员
所有其他的二元运算符 推荐作为非成员
 
当对象还没有被创建时，=调用的是构造函数或拷贝构造函数，为的是初始化对象；当对象已被创建时，=调用的才是operator=。因此
Fee fee(1);
Fee fum(fi);
这样的写法要比
Fee fee = 1;
Fee fum = fi;
这样的写法清晰。
 
在重载赋值运算符时，首先检查是否是对自身赋值是个好习惯。
 
当对象中有指针时，拷贝构造函数通常需要连同复制出指针所指向的内容。而当此内容很大时，通常采用引用计数的方法，只在需要修改数据且引用数大于1时才复制内容。这种技术被称为copy-on-write。
 
当构造函数接受一个其他类型的对象作为参数时，编译器可以用它来进行自动类型转换。如果不需要这样的自动转换，在构造函数前加上explicit。
 
也可以重载operator 类型名 来定义自动类型转换。由于这种类型转换是由源对象完成的（不像构造函数的类型转换是由目标对象完成的），因此可以完成自定义对象到内置类型的转换。
 
运算符重载为非成员函数时，运算符两边都可以进行自动类型转换。
 
提供自动类型转换时注意两种类型之间只需提供一条转换路径，否则会出现二义性错误。
 
 
 
new和delete
 
new为对象分配空间并调用构造函数。delete调用对象的析构函数后释放对象的空间。
 
delete对于零指针无效，因此人们通常在delete之后将指针设为零，以防止多次delete带来的问题。
 
delete void*可能会带来问题。由于编译器不知道具体的类型，将导致对象的空间被释放而没有调用析构函数。这可能会引起内存泄漏。
 
a* p = new a[100];为数组中的每个对象分配空间并调用构造函数进行初始化。
delete []p;则完成相反的事。delete后的[]表示指针只是数组的首地址，编译器会自
动获取数组的大小完成释放工作。由于表示首地址，最好定义为常量：
a* const p =  new a[100];
 
当new找不到空间分配时，会调用new-handler。其默认行为是抛出异常。可以通过使用new.h中的set_new_handler()来定义作为new-handler的函数。
 
operator new和operator delete都可以被重载，用来完成一些自定义的内存管理功能：
void* operator new(size_t sz)
void operator delete(void* m)
 
当new和delete作为类的成员函数被重载时，为该类的对象分配空间时就会调用这些重载的操作符。
 
用于为数组分配空间的operator new[]和operator delete[]也能被重载。实际占用的空间比分配的要多4个字节，被系统用于存储数组的大小。
 
重载的new可以接受任意多个参数，比如定义第二个参数，用于指明在何处分配空间：
void* operator new(size_t, void* loc)
使用时：
X* xp = new(a) X;
其中的a就是第二个参数。采用这种形式的new可能需要显式调用析构函数：
xp->X::~X();
（因为对象可能不是构建在堆上，使用delete只能释放堆上的空间）
 
 
 
继承
 
合成和继承都需要在构造初始化列表中对子对象进行初始化。
 
一旦在子类中定义了一个与超类中同名的函数，超类中所有同名的函数，不管函数特征是否相同，都会变得不可见。
 
构造函数，析构函数，operator=不会在继承时进入子类。
 
继承默认是private的，即超类中的public成员在子类中也会变成private的。若只想暴露某些成员，可以在子类中的public部分使用using。这种情况下同名的重载函数会被全部暴露。
 
 
 
多态
 
C++中使用virtual关键字来声明函数为延迟绑定的（或动态绑定）。函数的定义中不需要virtual。使用了virtual之后， upcast时调用的就是子类的重载函数，否则只能调用基类的。（C++使用virtual来使得动态绑定成为可选的，这是出于效率的考虑。其他语言如 Java和Python等默认就是使用动态绑定的）
 
拥有纯虚函数的类是抽象类（提供了一个接口）。纯虚函数在virtual定义后加上=0。
 
继承抽象类的子类必须实现基类中所有的纯虚函数，否则就还是抽象类。
 
纯虚函数不能内联定义。在定义后则可以被子类使用。
 
传值的upcast会把对象切割，即子类会被切到只剩下基类的部分。抽象的基类可以避免这种情况，因为抽象类不允许实例化。
 
构造函数不能是virtual的，而析构函数可以。
 
 
 
模板
 
继承可以重用对象，而模板可以重用代码。
 
定义template时可以使用内置类型。它们的值可以是常量。如：
template<class T, int size = 100>
 
template不仅可以用来创建类模板，还能用来创建函数模板。
 
 
 
杂项
 
之间没有标点符号的字符数组会被自动连接起来
 
C++标准中包含的不是STL，而是C++标准库，它是由STL演变来的。
 
?运算符中:的两边必须都有表达式。
 
以,分隔的表达式，最后一个表达式的值会被返回。
 
C++中的类型转换可以函数的形式，如float(n)等价于(float)n。
 
C++中的显示类型转换（提供一种容易辨别的形式）：
static_cast：类型收窄时可以避免编译器的警告信息；同样可用于类型放宽、void*的强制转换和自动隐式转换。
const_cast：用于转换const和volatile，比如将一个普通指针指向一个const
reinterpret_cast：把一种类型当成另一种类型
dynamic_cast：用于downcast
 
sizeof是运算符而不是函数，用于类型时要加括号，如sizeof(double)，用于变量时不用，如sizeof x。
 
显式运算符：
逻辑运算符
and &&
or  ||
not !
not_eq !=
位运算符
bitand &
bitor |
xor ^
and_eq &=
or_eq |=
xor_eq ^=
compl ~