C++知识点总结
2014-05-29 02:12
363 查看
C++知识点总结
一、#include "filename.h"和#include 的区别
#include "filename.h"是指编译器将从当前工作目录上开始查找此文件
#include 是指编译器将从标准库目录中开始查找此文件
二、头文件的作用
加强安全检测
通过头文件可能方便地调用库功能，而不必关心其实现方式
三、* , &修饰符的位置
对于*和&修饰符，为了避免误解，最好将修饰符紧靠变量名
四、if语句
不要将布尔变量与任何值进行比较，那会很容易出错的。
整形变量必须要有类型相同的值进行比较
浮点变量最好少比点，就算要比也要有值进行限制
指针变量要和NULL进行比较，不要和布尔型和整形比较
五、const和#define的比较
const有数据类型，#define没有数据类型
个别编译器中const可以进行调试，#define不可以进行调试
在类中定义常量有两种方式
1、 在类在声明常量，但不赋值，在构造函数初始化表中进行赋值；
2、 用枚举代替const常量。
六、C++函数中值的传递方式
有三种方式：值传递(Pass by value)、指针传递(Pass by pointer)、引用传递(Pass by reference)
void fun(char c) //pass by value
void fun(char *str) //pass by pointer
void fun(char &str) //pass by reference
如果输入参数是以值传递的话，最好使用引用传递代替，因为引用传递省去了临时对象的构造和析构
函数的类型不能省略，就算没有也要加个void
七、函数体中的指针或引用常量不能被返回
Char *func(void)
{
char str[]="Hello Word";
//这个是不能被返回的，因为str是个指定变量，不是一般的值，函数结束后会被注销掉
return str;
}
函数体内的指针变量并不会随着函数的消亡而自动释放
八、一个内存拷贝函数的实现体
void *memcpy(void *pvTo,const void *pvFrom,size_t size)
{
assert((pvTo!=NULL)&&(pvFrom!=NULL));
byte *pbTo=(byte*)pvTo; //防止地址被改变
byte *pbFrom=(byte*)pvFrom;
while (size-- >0)
pbTo++ = pbForm++;
return pvTo;
}
九、内存的分配方式
分配方式有三种，请记住，说不定那天去面试的时候就会有人问你这问题
1、 静态存储区，是在程序编译时就已经分配好的，在整个运行期间都存在，如全局变量、常量。
2、 栈上分配，函数内的局部变量就是从这分配的，但分配的内存容易有限。
3、 堆上分配，也称动态分配，如我们用new,malloc分配内存，用delete,free来释放的内存。
十、内存分配的注意事项
用new或malloc分配内存时，必须要对此指针赋初值。
用delete 或free释放内存后，必须要将指针指向NULL
不能修改指向常量的指针数据
十一、内容复制与比较
//数组......
char a[]="Hello Word!";
char b[10];
strcpy(b,a);
if (strcmp(a,b)==0)
{}
//指针......
char a[]="Hello Word!";
char *p;
p=new char[strlen(a)+1];
strcpy(p,a);
if (strcmp(p,a)==0)
{}
十二、sizeof的问题
记住一点，C++无法知道指针所指对象的大小，指针的大小永远为4字节
char a[]="Hello World!"
char *p=a;
count<
count<
而且，在函数中，数组参数退化为指针，所以下面的内容永远输出为4
void fun(char a[1000])
{
count<
}
十三、关于指针
1、 指针创建时必须被初始化
2、 指针在free 或delete后必须置为NULL
3、 指针的长度都为4字节
４、释放内存时，如果是数组指针，必须要释放掉所有的内存，如
char *p=new char[100];
strcpy(p,"Hello World");
delete []p; //注意前面的［］号
p=NULL;
５、数组指针的内容不能超过数组指针的最大容易。
如:
char *p=new char[5];
strcpy(p,"Hello World"); //报错 目标容易不够大
delete []p; //注意前面的［］号
p=NULL;
十四、关于malloc/free 和new /delete
l malloc/free 是C/C+的内存分配符，new /delete是C++的内存分配符。
l 注意：malloc/free是库函数，new/delete是运算符
l malloc/free不能执行构造函数与析构函数，而new/delete可以
l new/delete不能在C上运行，所以malloc/free不能被淘汰
l 两者都必须要成对使用
l C++中可以使用_set_new_hander函数来定义内存分配异常的处理
十五、Ｃ++的特性
Ｃ++新增加有重载(overload)，内联（inline），Const，Virtual四种机制
重载和内联：即可用于全局函数，也可用于类的成员函数；
Const和Virtual：只可用于类的成员函数；
重载：在同一类中，函数名相同的函数。由不同的参数决定调用那个函数。函数可要不可要Virtual关键字。和全局函数同名的函数不叫重载。如果在类中调用同名的全局函数，必须用全局引用符号::引用。
覆盖是指派生类函数覆盖基类函数
函数名相同；
参数相同；
基类函数必须有Virtual关键字；
不同的范围(派生类和基类)。
隐藏是指派生类屏蔽了基类的同名函数相同
1、 函数名相同，但参数不同，此时不论基类有无Virtual关键字，基类函数将被隐藏。
2、 函数名相同，参数也相同，但基类无Virtual关键字(有就是覆盖)，基类函数将被隐藏。
内联：inline关键字必须与定义体放在一起，而不是单单放在声明中。
Const：const是constant的缩写，"恒定不变"的意思。被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。
1、 参数做输入用的指针型参数，加上const可防止被意外改动。
2、 按值引用的用户类型做输入参数时，最好将按值传递的改为引用传递，并加上const关键字，目的是为了提高效率。数据类型为内部类型的就没必要做这件事情；如：
将void Func(A a) 改为void Func(const A &a)。
而void func(int a)就没必要改成void func(const int &a);
3、 给返回值为指针类型的函数加上const，会使函数返回值不能被修改，赋给的变量也只能是const型变量。如：函数const char*GetString(void); char *str=GetString()将会出错。而const char *str=GetString()将是正确的。
4、 Const成员函数是指此函数体内只能调用Const成员变量，提高程序的键壮性。如声明函数 int GetCount(void) const;此函数体内就只能调用Const成员变量。
Virtual：虚函数：派生类可以覆盖掉的函数，纯虚函数：只是个空函数，没有函数实现体；
十六、extern"C"有什么作用？
Extern "C"是由Ｃ＋＋提供的一个连接交换指定符号，用于告诉Ｃ＋＋这段代码是Ｃ函数。这是因为C++编译后库中函数名会变得很长，与C生成的不一致，造成Ｃ＋＋不能直接调用C函数，加上extren "c"后，C++就能直接调用C函数了。
Extern "C"主要使用正规DLL函数的引用和导出 和 在C++包含C函数或C头文件时使用。使用时在前面加上extern "c" 关键字即可。
十七、构造函数与析构函数
派生类的构造函数应在初始化表里调用基类的构造函数；
派生类和基类的析构函数应加Virtual关键字。
不要小看构造函数和析构函数，其实编起来还是不容易。
#include
class Base
{
public:
virtual ~Base() { cout<< "~Base" << endl ; }
};
class Derived : public Base
{
public:
virtual ~Derived() { cout<< "~Derived" << endl ; }
};
void main(void)
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 ~
转载自：http://blog.donews.com/toicecream/archive/2005/08/23/522264.aspx
1.函数模板：实际上是建立一个通用函数，其函数类型和参数类型不具体指定，用一个虚拟的类型来代表，这个通用函数就是函数模板。
#include <iostream>
template <typename T>
T const& max(T const& a,T const& b)
{
return a>b?a:b;
}
int main(){
int ia=16,ib=12;
std::cout<<"a,b中的最大值为："<<max(ia,ib)<<"\n";
getchar();
}
2.只有类外定义的成员函数规模很小而调用频率较高时，才能将此成员函数指定为内置函数。使用inline关键字。
举例：inline void display();
3.类的数据成员是不能再声明类时初始化的。
4.构造函数：是一种特殊的成员函数，与其他成员函数不同，不需要用户来调用它，而是在建立对象时自动执行。\
构造函数的名字必须与类名同名，而不能由用户任意命名，以便编译系统能识别它并把它作为构造函数处理。
5.参数初始化表实现对数据成员的初始化，这种方法不在函数体内对数据成员初始化，而是在函数首部实现。
举例：Box：Box(int h,int w,int len):height(h),width(w),length(len){}
6.析构函数：也是一个特殊的成员函数，它的作用于构造函数相反，它的名字是类名前面加一个“~”符号，
在C++中“~”是取反运算符，从这点也可以想到：析构函数是与构造函数作用相反的函数。
析构函数的作用并不是删除对象，而是在撤销对象占用内存之前完成一些清理工作。析构函数不能重载。（肯定的，无参怎么重载）
7.this指针：在每一个成员函数中都包括一个特殊的指针，这个指针的名字是固定的，称为this。
它是指向本类对象的指针，它的值是当前被调用的成员函数所在对象的起始地址。
8.对象的常引用：把实参变量的地址传给形参，这样引用名也指向实参变量。
#include <iostream>
using namespace std;
class Time{
public:
Time(int,int,int);
int hour;
int minute;
int sec;
};
Time::Time(int h,int m,int s){
hour=h;
minute=m;
sec=s;
}
void fun(Time &t){
t.hour=18;
}
int main(){
Time t1(10,13,56);
fun(t1);
cout<<t1.hour<<endl;
getchar();
return 0;
}
9.const的用法，概括来说就是被他修饰的对象，函数，变量或指针程序运行过程中不能别改变。（自己总结的）
10.对象的复制：用一个已有的对象快速的复制出多个完全相同的对象。
举例：Box:box2(box1);
11.静态数据成员：以关键字static开头，如果想在同类的多个对象之间实现数据共享，也不要用全局对象，可以用静态的数据成员。
静态数据成员可以初始化，但只能在类体外进行初始化。成员函数也可以定义为静态的，在类中声明函数的前面加static就成了静态
成员函数。和静态数据成员一样，静态成员函数是类的一部分，而不是对象的一部分。如果要在类外调用共用的静态成员函数，要用
类名和域运算符“：：”。静态员函数的作用不是为了对象之间的沟通，而是为了能处理静态数据成员。静态函数没有this指针。既
然它没有指向某一对象，它就无法对一个对象中的非静态成员进默认访问（记在引用数据成员时不指定对象名）。
静态成员函数与非静态成员函数的根本区别是：非静态成员函数有this指针，而静态成员函数没有this指针。由此决定了静态成员函
数不能访问本类中的非静态成员。静态成员函数可以直接引用本类中的静态数据成员，因为静态成员函数同样是属于本类的，可以直
接引用。在C++中，静态成员函数主要用来访问静态数据成员，而不访问非静态成员。
12.友元：在本类中用friend对该函数进行声明此函数就称为本类的友元函数。一个类的有元函数可以访问这个类中的私有成员（破坏
了封装性，但是要考，还是要记住）。Friend函数不仅可以是一般的函数（非成员函数），而且可以是另一类中的成员函数。
一个函数（包括普通函数和成员函数）可以被多个类声明为“朋友”，这样就可以应用多个类中的私有数据。
13.C++允许对类作“提前引用”的声明，即在正式声明一个类之前，先声明一个类名，表示此类将在稍后声明。
14.类模板：模板是类的抽象，类是模板的实例。
#include <iostream>
using namespace std;
template<class numtype>
class Point{
private:
numtype x,y;
public:
Point(numtype a,numtype b){
x=a;y=b;
}
numtype addX(Point q){
return x+q.x;
}
numtype addY(Point q){
return y+q.y;
}
numtype minX(Point q){
return x-q.x;
}
numtype minY(Point q){
return y-q.y;
}
};
int main(){
Point<int>p1(2,3);
Point<int>p2(3,4);
Point<double>p3(5.2,3.2);
Point<double>p4(6.4,3.0);
cout<<"第一个点加第二个点后坐标为："<<p1.addX(p2)<<","<<p1.addY(p2)<<endl;
cout<<"第三个点减第四个点后坐标为："<<p3.minX(p4)<<","<<p3.minY(p4)<<endl;
getchar();
return 0;
}
15.运算符重载：
运算符重载的方法是定义一个重载运算符的函数，在需要执行被重载的运算时，系统就自动调用该函数，实现相应的
运算。也就是说，运算重载是通过定义函数实现的。运算符重载实质上是函数的重载。
#include <iostream>
using namespace std;
//字符串操作类
class String
{
public :
String (){p=NULL;}
String (char *str){p=str;}
friend bool operator>(String &string1,String &string2);
friend bool operator<(String &string1,String &string2);
friend bool operator==(String &string1,String &string2);
void display();
private:
char *p;
};
//输出
void String::display()
{
cout<<p;
}
//运算符重载
bool operator>(String &string1,String &string2)
{
if(strcmp(string1.p,string2.p)>0)
return true;
else
return false;
}
//运算符重载
bool operator<(String &string1,String &string2)
{
if(strcmp(string1.p,string2.p)<0)
return true;
else
return false;
}
//运算符重载
bool operator ==(String &string1,String &string2)
{
if(strcmp(string1.p,string2.p)==0)
return true;
else
return false;
}
//比较
void compare(String &string1,String &string2)
{
if(operator>(string1,string2)==1)
{
string1.display();cout<<">";string2.display();
}
else if(operator<(string1,string2))
{
string1.display();cout<<"<";string2.display();
}
else
{
string1.display();cout<<"=";string2.display();
}
cout<<endl;
}
//时间类
class Time
{
public:
Time(){minute=0;sec=0;}
Time(int m,int s):minute(m),sec(s){}
Time operator++();
Time operator++(int);
//显示
void display(){cout<<minute<<":"<<sec<<endl;}
private:
int minute;
int sec;
};
//运算符重载
Time Time::operator ++()
{
if(++sec>=60)
{
sec-=60;
++minute;
}
return *this;
}
//运算符重载
Time Time::operator ++(int)
{
Time temp(*this);
sec++;
if(sec>=60)
{
sec-=60;
minute++;
}
return temp;
}
//复杂数类
class Complex
{
public:
Complex(){real=0;imag=0;}
Complex(double r,double i):real(r),imag(i){}
Complex operator+(Complex &c2);
friend ostream &operator<<(ostream &,Complex &);
friend istream &operator>>(istream &,Complex &);
private:
double real;
double imag;
};
//运算符重载
Complex Complex::operator +(Complex &c2)
{
return Complex(real+c2.real,imag+c2.imag);
}
//输出流运算符重载
ostream &operator<<(ostream &output,Complex &c)
{
output<<"("<<c.real<<"+"<<c.imag<<"i)"<<endl;
return output;
}
//输入流运算符重载
istream &operator>>(istream &input,Complex &c)
{
cout<<"input real part and imag part of complex number: ";
input>>c.real>>c.imag;
return input;
}
//主函数
int main()
{
//建立对象
String string1("Hello"),string2("Book"),string3("Compare"),string4("Hello");
Time time(34,0),time2;
Complex c1(2,4),c2(6,10),c3;
Complex c5,c4;
//验证运算符是否重载
cin>>c3>>c4;
cout <<"c3:"<<c3<<endl;
for(int i=0;i<100;i++)
{
++time;
time.display();
}
time2++;
cout<<"time2++:";time2.display();
compare(string1,string2);
compare(string2,string3);
compare(string1,string4);
c3=c1+c2;
return 0;
}
16.派生类（通俗点说就是子类）：
在声明派生类时，派生类并没有把积累的构造函数继承过来，因此，对继承过来的基类成员初始化的工作也要用派生
类的构造函数承担。所以在设计派生类的构造函数时，不仅要考虑派生类所增加的数据成员的初始化，还应当考虑
基类的数据成员初始化。也就是说，希望在执行派生类的构造函数时，是派生类的数据成员和基类的数据成员同时都
被初始化。解决这个问题的思路是：在执行派生类的构造函数时，调用基类的构造函数。
在执行派生类的析构函数时，系统会自动调用基类函数的析构函数和子对象的析构函数，对基类和子对象进行清理。
调用的顺序与析构函数正好相反，先执行派生类自己的析构函数，对派生类新增加的成员进行清理，然后调用子对象
的析构函数，对子对象进行清理，最后调用基类的析构函数，对基类进行清理。
#include<iostream>
using namespace std;
class Student{
public:
Student(int n,string nam,char s){
num=n;
name=nam;
sex=s;
}
~Student(){}
protected:
int num;
string name;
char sex;
};
class Student1:public Student{
public:
Student1(int n,string nam,char s,int a,string ad):Student(n,nam,s){
age=a;
addr=ad;
}
void show(){
cout<<"num:"<<num<<endl;
cout<<"name:"<<name<<endl;
cout<<"sex:"<<sex<<endl;
cout<<"age:"<<age<<endl;
cout<<"address:"<<addr<<endl<<endl;
}
~Student1(){}
private:
int age;
string addr;
};
int main(){
Student1 stud1(10010,"Shiyang",'f',19,"115 XingTai");
Student1 stud2(10010,"hahahha",'m',21,"110 Beijing");
stud1.show();
stud2.show();
getchar();
return 0;
}
17.多态：多态分为两类：静态多态性和动态多态性，以前学过的函数重载和运算符重载实现的多态性属于静态多态性，在
程序编译时系统就能决定调用哪个函数，因此静态多态性又称为编译时的多态性。静态多态性是通过函数的重载实现的。
动态多态性是在程序运行过程中才动态地确定操作所针对的对象。它又称运行时的多态性。动态多态性是通过虚函数实现的。
18.虚函数：
虚函数的作用是允许在派生类中重新定义与基类同名的的函数，并且可以通过基类指针或引用来访问基类和派生类中的同名函数。
#include <iostream>
#include <complex>
using namespace std;
class Base {
public:
virtual void f( int ) {
cout << "Base::f(int)" << endl;
}
virtual void f( double ) {
cout << "Base::f(double)" << endl;
}
virtual void g( int i = 20 ) {
cout << i << endl;
}
};
class Derived: public Base {
public:
void f( complex<double> ) {
cout << "Derived::f(complex)" << endl;
}
void g( int i = 10 ) {
cout << "Derived::g() " << i << endl;
}
};
int main() {
Base b;
Derived d;
Base* pb = new Derived;
b.f(1.0);
d.f(1.0);
pb->f(1.0);
b.g();
d.g();
pb->g();
delete pb;
return 0;
}
19.如果用new运算符建立了临时对象。若基类中有析构函数，并且定义了一个指向该基类的指针变量。在程序用带指针
的参数的delete运算符撤销对象时，会发生一个情况：系统只会执行基类的析构函数，而不执行派生类的析构函数。
声明虚析构函数，即使基类并不需要析构函数，也显示的定义一个函数体为空的虚析构函数，以保证在撤销动态存储空间是能得到
正确的处理。（专业）
20.C++提供虚基类地方法，使得在继承间接共同基类时只保留一份成员。
21.构造函数不能声明为虚函数。这是因为在执行构造函数时类对象还未完成建立过程，当然谈不上函数与类对象的关联。
22.纯虚函数的作用是在基类中为其派生类保留一个函数的名字，以便派生类根据需要对他进行定义。如果在基类中没有保留函数
名字，则无法实现多态性。
23.抽象类：这种不用来定义对象而只作为一种基本类型用作继承的类，称为抽象类。由于由于他常用作基类，通常称
为抽象基类。凡是包含纯虚数的类都是抽象类。因为纯虚函数是不能被调用的，包含纯虚函数的类是无法建立对象的。
抽象类的作用是作为一个类族的共同基类，或者说，为一类族提供一个公共接口。
24.以上是我考试的全部考点，为了辅助说明，我也举了一些源码，提供大家理解。好辛苦啊~~~~
转载注明：www.cnblogs.com/shiyangxt
一、#include "filename.h"和#include 的区别
#include "filename.h"是指编译器将从当前工作目录上开始查找此文件
#include 是指编译器将从标准库目录中开始查找此文件
二、头文件的作用
加强安全检测
通过头文件可能方便地调用库功能，而不必关心其实现方式
三、* , &修饰符的位置
对于*和&修饰符，为了避免误解，最好将修饰符紧靠变量名
四、if语句
不要将布尔变量与任何值进行比较，那会很容易出错的。
整形变量必须要有类型相同的值进行比较
浮点变量最好少比点，就算要比也要有值进行限制
指针变量要和NULL进行比较，不要和布尔型和整形比较
五、const和#define的比较
const有数据类型，#define没有数据类型
个别编译器中const可以进行调试，#define不可以进行调试
在类中定义常量有两种方式
1、 在类在声明常量，但不赋值，在构造函数初始化表中进行赋值；
2、 用枚举代替const常量。
六、C++函数中值的传递方式
有三种方式：值传递(Pass by value)、指针传递(Pass by pointer)、引用传递(Pass by reference)
void fun(char c) //pass by value
void fun(char *str) //pass by pointer
void fun(char &str) //pass by reference
如果输入参数是以值传递的话，最好使用引用传递代替，因为引用传递省去了临时对象的构造和析构
函数的类型不能省略，就算没有也要加个void
七、函数体中的指针或引用常量不能被返回
Char *func(void)
{
char str[]="Hello Word";
//这个是不能被返回的，因为str是个指定变量，不是一般的值，函数结束后会被注销掉
return str;
}
函数体内的指针变量并不会随着函数的消亡而自动释放
八、一个内存拷贝函数的实现体
void *memcpy(void *pvTo,const void *pvFrom,size_t size)
{
assert((pvTo!=NULL)&&(pvFrom!=NULL));
byte *pbTo=(byte*)pvTo; //防止地址被改变
byte *pbFrom=(byte*)pvFrom;
while (size-- >0)
pbTo++ = pbForm++;
return pvTo;
}
九、内存的分配方式
分配方式有三种，请记住，说不定那天去面试的时候就会有人问你这问题
1、 静态存储区，是在程序编译时就已经分配好的，在整个运行期间都存在，如全局变量、常量。
2、 栈上分配，函数内的局部变量就是从这分配的，但分配的内存容易有限。
3、 堆上分配，也称动态分配，如我们用new,malloc分配内存，用delete,free来释放的内存。
十、内存分配的注意事项
用new或malloc分配内存时，必须要对此指针赋初值。
用delete 或free释放内存后，必须要将指针指向NULL
不能修改指向常量的指针数据
十一、内容复制与比较
//数组......
char a[]="Hello Word!";
char b[10];
strcpy(b,a);
if (strcmp(a,b)==0)
{}
//指针......
char a[]="Hello Word!";
char *p;
p=new char[strlen(a)+1];
strcpy(p,a);
if (strcmp(p,a)==0)
{}
十二、sizeof的问题
记住一点，C++无法知道指针所指对象的大小，指针的大小永远为4字节
char a[]="Hello World!"
char *p=a;
count<
count<
而且，在函数中，数组参数退化为指针，所以下面的内容永远输出为4
void fun(char a[1000])
{
count<
}
十三、关于指针
1、 指针创建时必须被初始化
2、 指针在free 或delete后必须置为NULL
3、 指针的长度都为4字节
４、释放内存时，如果是数组指针，必须要释放掉所有的内存，如
char *p=new char[100];
strcpy(p,"Hello World");
delete []p; //注意前面的［］号
p=NULL;
５、数组指针的内容不能超过数组指针的最大容易。
如:
char *p=new char[5];
strcpy(p,"Hello World"); //报错 目标容易不够大
delete []p; //注意前面的［］号
p=NULL;
十四、关于malloc/free 和new /delete
l malloc/free 是C/C+的内存分配符，new /delete是C++的内存分配符。
l 注意：malloc/free是库函数，new/delete是运算符
l malloc/free不能执行构造函数与析构函数，而new/delete可以
l new/delete不能在C上运行，所以malloc/free不能被淘汰
l 两者都必须要成对使用
l C++中可以使用_set_new_hander函数来定义内存分配异常的处理
十五、Ｃ++的特性
Ｃ++新增加有重载(overload)，内联（inline），Const，Virtual四种机制
重载和内联：即可用于全局函数，也可用于类的成员函数；
Const和Virtual：只可用于类的成员函数；
重载：在同一类中，函数名相同的函数。由不同的参数决定调用那个函数。函数可要不可要Virtual关键字。和全局函数同名的函数不叫重载。如果在类中调用同名的全局函数，必须用全局引用符号::引用。
覆盖是指派生类函数覆盖基类函数
函数名相同；
参数相同；
基类函数必须有Virtual关键字；
不同的范围(派生类和基类)。
隐藏是指派生类屏蔽了基类的同名函数相同
1、 函数名相同，但参数不同，此时不论基类有无Virtual关键字，基类函数将被隐藏。
2、 函数名相同，参数也相同，但基类无Virtual关键字(有就是覆盖)，基类函数将被隐藏。
内联：inline关键字必须与定义体放在一起，而不是单单放在声明中。
Const：const是constant的缩写，"恒定不变"的意思。被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。
1、 参数做输入用的指针型参数，加上const可防止被意外改动。
2、 按值引用的用户类型做输入参数时，最好将按值传递的改为引用传递，并加上const关键字，目的是为了提高效率。数据类型为内部类型的就没必要做这件事情；如：
将void Func(A a) 改为void Func(const A &a)。
而void func(int a)就没必要改成void func(const int &a);
3、 给返回值为指针类型的函数加上const，会使函数返回值不能被修改，赋给的变量也只能是const型变量。如：函数const char*GetString(void); char *str=GetString()将会出错。而const char *str=GetString()将是正确的。
4、 Const成员函数是指此函数体内只能调用Const成员变量，提高程序的键壮性。如声明函数 int GetCount(void) const;此函数体内就只能调用Const成员变量。
Virtual：虚函数：派生类可以覆盖掉的函数，纯虚函数：只是个空函数，没有函数实现体；
十六、extern"C"有什么作用？
Extern "C"是由Ｃ＋＋提供的一个连接交换指定符号，用于告诉Ｃ＋＋这段代码是Ｃ函数。这是因为C++编译后库中函数名会变得很长，与C生成的不一致，造成Ｃ＋＋不能直接调用C函数，加上extren "c"后，C++就能直接调用C函数了。
Extern "C"主要使用正规DLL函数的引用和导出 和 在C++包含C函数或C头文件时使用。使用时在前面加上extern "c" 关键字即可。
十七、构造函数与析构函数
派生类的构造函数应在初始化表里调用基类的构造函数；
派生类和基类的析构函数应加Virtual关键字。
不要小看构造函数和析构函数，其实编起来还是不容易。
#include
class Base
{
public:
virtual ~Base() { cout<< "~Base" << endl ; }
};
class Derived : public Base
{
public:
virtual ~Derived() { cout<< "~Derived" << endl ; }
};
void main(void)
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 ~
转载自：http://blog.donews.com/toicecream/archive/2005/08/23/522264.aspx
1.函数模板：实际上是建立一个通用函数，其函数类型和参数类型不具体指定，用一个虚拟的类型来代表，这个通用函数就是函数模板。
#include <iostream>
template <typename T>
T const& max(T const& a,T const& b)
{
return a>b?a:b;
}
int main(){
int ia=16,ib=12;
std::cout<<"a,b中的最大值为："<<max(ia,ib)<<"\n";
getchar();
}
2.只有类外定义的成员函数规模很小而调用频率较高时，才能将此成员函数指定为内置函数。使用inline关键字。
举例：inline void display();
3.类的数据成员是不能再声明类时初始化的。
4.构造函数：是一种特殊的成员函数，与其他成员函数不同，不需要用户来调用它，而是在建立对象时自动执行。\
构造函数的名字必须与类名同名，而不能由用户任意命名，以便编译系统能识别它并把它作为构造函数处理。
5.参数初始化表实现对数据成员的初始化，这种方法不在函数体内对数据成员初始化，而是在函数首部实现。
举例：Box：Box(int h,int w,int len):height(h),width(w),length(len){}
6.析构函数：也是一个特殊的成员函数，它的作用于构造函数相反，它的名字是类名前面加一个“~”符号，
在C++中“~”是取反运算符，从这点也可以想到：析构函数是与构造函数作用相反的函数。
析构函数的作用并不是删除对象，而是在撤销对象占用内存之前完成一些清理工作。析构函数不能重载。（肯定的，无参怎么重载）
7.this指针：在每一个成员函数中都包括一个特殊的指针，这个指针的名字是固定的，称为this。
它是指向本类对象的指针，它的值是当前被调用的成员函数所在对象的起始地址。
8.对象的常引用：把实参变量的地址传给形参，这样引用名也指向实参变量。
#include <iostream>
using namespace std;
class Time{
public:
Time(int,int,int);
int hour;
int minute;
int sec;
};
Time::Time(int h,int m,int s){
hour=h;
minute=m;
sec=s;
}
void fun(Time &t){
t.hour=18;
}
int main(){
Time t1(10,13,56);
fun(t1);
cout<<t1.hour<<endl;
getchar();
return 0;
}
9.const的用法，概括来说就是被他修饰的对象，函数，变量或指针程序运行过程中不能别改变。（自己总结的）
10.对象的复制：用一个已有的对象快速的复制出多个完全相同的对象。
举例：Box:box2(box1);
11.静态数据成员：以关键字static开头，如果想在同类的多个对象之间实现数据共享，也不要用全局对象，可以用静态的数据成员。
静态数据成员可以初始化，但只能在类体外进行初始化。成员函数也可以定义为静态的，在类中声明函数的前面加static就成了静态
成员函数。和静态数据成员一样，静态成员函数是类的一部分，而不是对象的一部分。如果要在类外调用共用的静态成员函数，要用
类名和域运算符“：：”。静态员函数的作用不是为了对象之间的沟通，而是为了能处理静态数据成员。静态函数没有this指针。既
然它没有指向某一对象，它就无法对一个对象中的非静态成员进默认访问（记在引用数据成员时不指定对象名）。
静态成员函数与非静态成员函数的根本区别是：非静态成员函数有this指针，而静态成员函数没有this指针。由此决定了静态成员函
数不能访问本类中的非静态成员。静态成员函数可以直接引用本类中的静态数据成员，因为静态成员函数同样是属于本类的，可以直
接引用。在C++中，静态成员函数主要用来访问静态数据成员，而不访问非静态成员。
12.友元：在本类中用friend对该函数进行声明此函数就称为本类的友元函数。一个类的有元函数可以访问这个类中的私有成员（破坏
了封装性，但是要考，还是要记住）。Friend函数不仅可以是一般的函数（非成员函数），而且可以是另一类中的成员函数。
一个函数（包括普通函数和成员函数）可以被多个类声明为“朋友”，这样就可以应用多个类中的私有数据。
13.C++允许对类作“提前引用”的声明，即在正式声明一个类之前，先声明一个类名，表示此类将在稍后声明。
14.类模板：模板是类的抽象，类是模板的实例。
#include <iostream>
using namespace std;
template<class numtype>
class Point{
private:
numtype x,y;
public:
Point(numtype a,numtype b){
x=a;y=b;
}
numtype addX(Point q){
return x+q.x;
}
numtype addY(Point q){
return y+q.y;
}
numtype minX(Point q){
return x-q.x;
}
numtype minY(Point q){
return y-q.y;
}
};
int main(){
Point<int>p1(2,3);
Point<int>p2(3,4);
Point<double>p3(5.2,3.2);
Point<double>p4(6.4,3.0);
cout<<"第一个点加第二个点后坐标为："<<p1.addX(p2)<<","<<p1.addY(p2)<<endl;
cout<<"第三个点减第四个点后坐标为："<<p3.minX(p4)<<","<<p3.minY(p4)<<endl;
getchar();
return 0;
}
15.运算符重载：
运算符重载的方法是定义一个重载运算符的函数，在需要执行被重载的运算时，系统就自动调用该函数，实现相应的
运算。也就是说，运算重载是通过定义函数实现的。运算符重载实质上是函数的重载。
#include <iostream>
using namespace std;
//字符串操作类
class String
{
public :
String (){p=NULL;}
String (char *str){p=str;}
friend bool operator>(String &string1,String &string2);
friend bool operator<(String &string1,String &string2);
friend bool operator==(String &string1,String &string2);
void display();
private:
char *p;
};
//输出
void String::display()
{
cout<<p;
}
//运算符重载
bool operator>(String &string1,String &string2)
{
if(strcmp(string1.p,string2.p)>0)
return true;
else
return false;
}
//运算符重载
bool operator<(String &string1,String &string2)
{
if(strcmp(string1.p,string2.p)<0)
return true;
else
return false;
}
//运算符重载
bool operator ==(String &string1,String &string2)
{
if(strcmp(string1.p,string2.p)==0)
return true;
else
return false;
}
//比较
void compare(String &string1,String &string2)
{
if(operator>(string1,string2)==1)
{
string1.display();cout<<">";string2.display();
}
else if(operator<(string1,string2))
{
string1.display();cout<<"<";string2.display();
}
else
{
string1.display();cout<<"=";string2.display();
}
cout<<endl;
}
//时间类
class Time
{
public:
Time(){minute=0;sec=0;}
Time(int m,int s):minute(m),sec(s){}
Time operator++();
Time operator++(int);
//显示
void display(){cout<<minute<<":"<<sec<<endl;}
private:
int minute;
int sec;
};
//运算符重载
Time Time::operator ++()
{
if(++sec>=60)
{
sec-=60;
++minute;
}
return *this;
}
//运算符重载
Time Time::operator ++(int)
{
Time temp(*this);
sec++;
if(sec>=60)
{
sec-=60;
minute++;
}
return temp;
}
//复杂数类
class Complex
{
public:
Complex(){real=0;imag=0;}
Complex(double r,double i):real(r),imag(i){}
Complex operator+(Complex &c2);
friend ostream &operator<<(ostream &,Complex &);
friend istream &operator>>(istream &,Complex &);
private:
double real;
double imag;
};
//运算符重载
Complex Complex::operator +(Complex &c2)
{
return Complex(real+c2.real,imag+c2.imag);
}
//输出流运算符重载
ostream &operator<<(ostream &output,Complex &c)
{
output<<"("<<c.real<<"+"<<c.imag<<"i)"<<endl;
return output;
}
//输入流运算符重载
istream &operator>>(istream &input,Complex &c)
{
cout<<"input real part and imag part of complex number: ";
input>>c.real>>c.imag;
return input;
}
//主函数
int main()
{
//建立对象
String string1("Hello"),string2("Book"),string3("Compare"),string4("Hello");
Time time(34,0),time2;
Complex c1(2,4),c2(6,10),c3;
Complex c5,c4;
//验证运算符是否重载
cin>>c3>>c4;
cout <<"c3:"<<c3<<endl;
for(int i=0;i<100;i++)
{
++time;
time.display();
}
time2++;
cout<<"time2++:";time2.display();
compare(string1,string2);
compare(string2,string3);
compare(string1,string4);
c3=c1+c2;
return 0;
}
16.派生类（通俗点说就是子类）：
在声明派生类时，派生类并没有把积累的构造函数继承过来，因此，对继承过来的基类成员初始化的工作也要用派生
类的构造函数承担。所以在设计派生类的构造函数时，不仅要考虑派生类所增加的数据成员的初始化，还应当考虑
基类的数据成员初始化。也就是说，希望在执行派生类的构造函数时，是派生类的数据成员和基类的数据成员同时都
被初始化。解决这个问题的思路是：在执行派生类的构造函数时，调用基类的构造函数。
在执行派生类的析构函数时，系统会自动调用基类函数的析构函数和子对象的析构函数，对基类和子对象进行清理。
调用的顺序与析构函数正好相反，先执行派生类自己的析构函数，对派生类新增加的成员进行清理，然后调用子对象
的析构函数，对子对象进行清理，最后调用基类的析构函数，对基类进行清理。
#include<iostream>
using namespace std;
class Student{
public:
Student(int n,string nam,char s){
num=n;
name=nam;
sex=s;
}
~Student(){}
protected:
int num;
string name;
char sex;
};
class Student1:public Student{
public:
Student1(int n,string nam,char s,int a,string ad):Student(n,nam,s){
age=a;
addr=ad;
}
void show(){
cout<<"num:"<<num<<endl;
cout<<"name:"<<name<<endl;
cout<<"sex:"<<sex<<endl;
cout<<"age:"<<age<<endl;
cout<<"address:"<<addr<<endl<<endl;
}
~Student1(){}
private:
int age;
string addr;
};
int main(){
Student1 stud1(10010,"Shiyang",'f',19,"115 XingTai");
Student1 stud2(10010,"hahahha",'m',21,"110 Beijing");
stud1.show();
stud2.show();
getchar();
return 0;
}
17.多态：多态分为两类：静态多态性和动态多态性，以前学过的函数重载和运算符重载实现的多态性属于静态多态性，在
程序编译时系统就能决定调用哪个函数，因此静态多态性又称为编译时的多态性。静态多态性是通过函数的重载实现的。
动态多态性是在程序运行过程中才动态地确定操作所针对的对象。它又称运行时的多态性。动态多态性是通过虚函数实现的。
18.虚函数：
虚函数的作用是允许在派生类中重新定义与基类同名的的函数，并且可以通过基类指针或引用来访问基类和派生类中的同名函数。
#include <iostream>
#include <complex>
using namespace std;
class Base {
public:
virtual void f( int ) {
cout << "Base::f(int)" << endl;
}
virtual void f( double ) {
cout << "Base::f(double)" << endl;
}
virtual void g( int i = 20 ) {
cout << i << endl;
}
};
class Derived: public Base {
public:
void f( complex<double> ) {
cout << "Derived::f(complex)" << endl;
}
void g( int i = 10 ) {
cout << "Derived::g() " << i << endl;
}
};
int main() {
Base b;
Derived d;
Base* pb = new Derived;
b.f(1.0);
d.f(1.0);
pb->f(1.0);
b.g();
d.g();
pb->g();
delete pb;
return 0;
}
19.如果用new运算符建立了临时对象。若基类中有析构函数，并且定义了一个指向该基类的指针变量。在程序用带指针
的参数的delete运算符撤销对象时，会发生一个情况：系统只会执行基类的析构函数，而不执行派生类的析构函数。
声明虚析构函数，即使基类并不需要析构函数，也显示的定义一个函数体为空的虚析构函数，以保证在撤销动态存储空间是能得到
正确的处理。（专业）
20.C++提供虚基类地方法，使得在继承间接共同基类时只保留一份成员。
21.构造函数不能声明为虚函数。这是因为在执行构造函数时类对象还未完成建立过程，当然谈不上函数与类对象的关联。
22.纯虚函数的作用是在基类中为其派生类保留一个函数的名字，以便派生类根据需要对他进行定义。如果在基类中没有保留函数
名字，则无法实现多态性。
23.抽象类：这种不用来定义对象而只作为一种基本类型用作继承的类，称为抽象类。由于由于他常用作基类，通常称
为抽象基类。凡是包含纯虚数的类都是抽象类。因为纯虚函数是不能被调用的，包含纯虚函数的类是无法建立对象的。
抽象类的作用是作为一个类族的共同基类，或者说，为一类族提供一个公共接口。
24.以上是我考试的全部考点，为了辅助说明，我也举了一些源码，提供大家理解。好辛苦啊~~~~
转载注明：www.cnblogs.com/shiyangxt
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 