c++如何申明template<classt>类型

第一章

1.动态分配内存

使用new关键字：1）为一个对象分配内存：指针名 = new 类型名；2）为一个对象数组分配内存：指针名 = new 类型名[长度]；

使用delete关键字：1）释放对象占用内存：delete 指针名；2）释放一个对象数组占用内存：delete []指针名。

注意：new和delete必须成对出现，且delete释放一个对象时，会调用析构函数。

2.引用

数据类型 &别名 = 对象名

例如：int a = 56; int &b = a ;则b是对a的引用

3.什么是左值和右值？

左值：必须是能被计算和修改的。

右值：右值表达式的值必须是固定的。

4.指向常量的指针

指向常量的指针一般形式：const int *p

注意：*p不能作为左值。

5.常量指针

常量指针一般形式： int * const p

注意：*p不能作为左值。

6.指向常量的常量指针

常量指针一般形式：const int * const p

注意：*p不能作为左值。

7.泛型算法应用于普通数组

对数组进行升幂排序，反转数组内容，复制数组等要包含<algorithm>头文件包

对数组进行降幂排序和检索要包含<functional>头文件包

（1）反转数组内容：reverse(a , a+数组长度)

（2）复制数组内容 : copy(a,a + 数组长度,b)

（3）reverse_copy(a ,a +数组长度 ,b);reverse_copy是将数组的内容从尾到头的逆向复制

（4）数组升幂排序：sort（a , a+数组长度）

（5）数组降幂排序 : sort(b , b+ 数组长度 , greater<Type>())

（6）查找数组内容 : find(a , a+数组长度 ,value)

（7）数组内容的输出：copy(a , a+ len ,ostream_iterator<Type>(cout,"字符串"));

注意：可将ostream_iyerator理解为输出流控制符，<Type>表示数组元素的数据类型"字符串"是数组元素间的间隔。

8.数据的简单输入输出

C++提高了两种格式控制方式：一种是使用ios_base类提供的接口；另一种是称为操控符的特殊函数，它的特点是可以直接包含在输出和输入表达式中，因此更加方便。

不带参数操控符定义在头文件<iostream>中，带形式的定义在头文件<iomanip>中

三是无参数的操控符函数不能带有()

常量及其含义

第二章

1.string 对象

（1）string对象包含于#include<string>头文件包中

（2）计算字符串长度的函数：size()，使用方法是 字符串.size()

（3）返回字符串子串的函数：substr(起始位置,结束位置)

注意：给出的起始位置必须位于字符串中，否则出错。如果结束位置大于字符串的长度，则自动截取到字符串尾部。

（4）字符串查找函数：find(要查找字符串,开始查找的位置)

（5）String类有一对用来指示其元素位置在的基本函数成员：begin()和end(),

Begin()指示第一个元素，end()指示最后一个元素之后。如果begin()不等于end()，则算法首先作用于begin()所指元素，然后指向下一个元素，知道begin()等于end()。所以元素存在于半开区间[begin,end)中。

（6）char定义的字符串使用“\0”作为结束标记。String不是。

2.使用complex对象

（1）这个对象包含于头文件#include<complex>中 。

使用方法：complex<数据类型> 对象名（实部值，虚部值）

Complex使用成员函数real()和imag()函数输出实部和虚部值

（2）string类型的数组的swap()成员函数可以交换连个数组分量。

第三章

1.函数的参数及其传递方式

（1）对象作为函数参数：将对象名作为函数参数，这种传递是单向的，不会改变实参的值。

（2）对象指针作为函数参数：将对象地址作为函数参数，这种传递会改变实参的值。

（3）引用作为函数参数：定义时，形参是别名；调用时，实参是对象名。实参对象和形参对象代表同一个对象，所以改变形参对象就是改变实参对象。

2.使用const保护数据：使用const修饰符传递参数，只能使用参数而无权修改参数。这样能提高系统安全。

3.函数返回值

（1）函数可以返回一个引用，返回一个引用的主要目的是为了将该函数用在赋值运算符的左边。函数原型表示方法：数据类型 &函数名(参数列表)

（2）返回指针函数：返回值是存储了某种类型数据的内存地址，这种 函数称为指针函数。声明函数原型表示方法：类型标示符 *函数名（参数列表）

注意：当函数返回一个空指针值是，这个可以作为程序异常的标志。

（3）返回对象：函数返回string等对象。

（4）函数返回值作为函数参数：如果把函数返回值作为另一个函数的参数，这个函数的返回值必须和参数类型一致。

4.内联函数

内联函数的声明只要在函数前加上关键字“inline”即可。内联函数必须在函数第一次被调用前出现并定义。

5.函数的重载和默认参数

函数重载指函数名相同，但输入参数类型不同或个数不同。

默认参数一般在参数列表中给出，int add(int m1 = 0,int m2 = 0)。

6.函数模板

在函数定义时加上Template <typename T> 或Template <class T>。实际调用时可以不指出T的数据类型，也可显式指出。

第四章

1.定义类

（1）声明类：class 类名{

Private：

私有数据和函数

Public：

共有数据和函数

Protected：

保护数据和函数

}；

注意：花括号后面的分号必不可少

（2）类外定义成员函数

一般形式：

返回类型 类名 ：：成员函数 （参数列表）

{

成员函数的函数体

}

注意：“：：”是作用域运算符，其意思表面其后的成员函数时属于这个特定的类。

（3）数据成员的赋值

注意：不能在定义数据成员的同时进行赋值，这种做法是错误的。

2.使用类的对象

（1）类不仅可以声明对象，还可以声明对象的引用和对象的指针，其语法与基本数据类型一样。

（2）定义类对象的指针语法：类名 * 对象指针名；

（3）数据封装这些内存块中不仅存储数据，也存储代码，这有利于数据和功能安全。同时这些内存块的结构可被用作样板产生跟多对象。

3.构造函数

（1）为了使对象的状态确定，必须对其进行正确的初始化。初始化的操作和赋值操作是不同的。

（2）默认构造函数：类名 ：：类名（）{}

注意：默认构造函数是系统自动产生的，当用户定义了自己的构造函数系统就不在提供默认构造函数。

（3）定义构造函数：构造函数的名字和类名相同，并且定义构造函数的时候不能有返回值类型，即使是void也不可以。

（4）类可有多个函数，在类体的声明形式如下：类名（形参1，形参2，形参3......形参n）；在程序中说明一个对象时，程序自动调用构造函数来初始化对象，使程序为对象自动化分配内存。

（5）程序员不能在程序中显示的调用构造函数，构造函数是自动调用的。

（6）构造函数和运算符new：运算符new用于建立生存期可控的对象，new返回这个对象的指针，因此使用new建立动态对象的语法和建立动态变量的情况类似，其不同点是new和构造函数一同起作用。

（7）当使用new建立一个动态对象，new首先分配足够对象的内存，然后自动构造函数来初始化这块内存，再返回这个动态对象的地址。

（8）构造函数的默认参数：如果程序定义自己的有参构造函数，又想使用无参数形式的构造函数，那么就是吧构造函数使用默认参数设计。

（9）复制构造函数：引用在类中一个很重要的用途是用在复制构造函数中。这一类特殊而且重要的函数通常用于使自己已有的对象来建立一个新对象。复制构造函数原型如下：类名：：类名(const 类名 &)

4.析构函数

（1）析构函数析构函数的名称和类名一样，为了与构造函数区分在析构函数前面加~符号。析构函数不能定义任何返回类型，即使指定为void也不行。一般形式如下：类名：：~类名（void）

（2）析构函数在对象的生存期结束时被主动调用。类得对象数组的每个元素调用一次构造函数。

（3）析构函数和运算符delete：当使用delete删除一个动态对象时，它首先为这个动态对象调用析构函数，然后再释放这个动态对象占用的内存。这和使用new建立动态对象的过程刚好相反。

5.成员函数重载及默认函数

（1）this指针：c++规定当一个成员函数被调用时，系统自动向它传递一个隐含的参数，该参数是一个指向调用该函数的指针，从而使成员函数知道该对那个对象进行操作。

（2）this指针是c++实现封装的一种机制，它将该对象调用的成员函数连接在一起，在外部看来，每一个对象都拥有自己的成员函数。一般情况下都省略符号“this->”,而让系统进行默认设置。

6.一个类的对象作为另一个类的成员

（1）类本身就是一种新的数据类型，所以一个类可以作为另一个类得成员。

7.类和对象的性质

（1）对象的性质：同一类的对象之间可以相互赋值，可以使用对象数组，可以使用指向对象的指针，使用取址运算符&讲一个对象的地址置于该指针中。

对象之间赋值：Point A,B; A.Set(25,25); B = A

数组对象：Point A[3]

使用指针和取址运算符：point *P = &A P->Display();

（2）对象可以作为函数参数，如果参数传递采用传对象值的方式，在被调用函数中对形参所作的改变不影响调用函数中作为实参的对象。如果传得是对象的引用（地址）当参数对象被修改时，相应的实参对象也会被修改。C++建议使用引用，在前面加上const这样可以避免修改原来的数据成员。

（3）对象作为函数参数时，可以使用对象，对象引用，和对象指针。形式为：

Void print（Point a）{a.Display;}//对象作为参数

Void print（Point &a）{a.Display;}//对象引用作为参数

Void print（Point *p）{p->Display;}//对象指针作为参数

（4）一个对象可以作为另一个类得成员。

8.类的性质

（1）类本身的成员函数可以使用类所以的成员

（2）类得对象只能访问公有成员函数，例如输出x只能使用A.Getx()，不能使用A.x

（3）其他函数不能使用类的私有成员，也不能使用类得公有成员函数，他们只能通过类的对象使用类得公有成员函数。

（4）虽然一个类可以包含另一个类的对象，但是这个类也只能通过它被包含的这个类得对象使用那个类的成员函数，通过成员函数使用数据成员，例如：Loc.Set(x,y)

（5）不完全类得声明：只要当使用类产生对象时，才进行内存分配，这种对象的建立过程称为实例化。

（6）有时候将类作为一个整体使用而不存取取成员。

（7）不完全类的定义没有类体。不完全类声明的类不能实例化

（8）类也可以是空的，不包含任何内容。

（9）类中的一个成员名可以使用类名和作用域运算符来显示的指定，这称为成员名限定。例如：void MyClass::set(int i){

MyClass::number = i//显示的指定访问MyClass类中的标示符number

}

9.对象，类和消息

（1）接收对象名，调用操作名和必要的参数是对象传达消息的一般组成部分。

第五章

1.对象成员的初始化

（1）可以在一个类中说明具有某个类的类型的数据成员，在A类中说明对象成员的一般形式如下：

Class A{

类名1 成员名1；

类名2 成员名2；

。

。

。

类名n 成员名n

}；

A类得构造函数的形式如下：

A：：A（参数表0）：成员1（参数表1），成员2（参数列表2），成员3（成员列表3）

{

其他操作。。。

}

（2）静态成员：简单成员函数是指声明中不含const ，volatile ，static关键字的函数，如果类得数据成员或成员函数使用关键字static进行修饰，这样的成员称为静态成员或静态成员函数，统称为静态成员。

（3）静态数据成员只能说明一次如果在类中仅对静态数据成员进行声明，则必须在文件作用域的某个地方进行定义。在进行初始化时，必须进行成员名限定。

例如：int Test :: x = 25

也可以直接在构造函数中使用类成员限定符对其进行初始化。

例如：Test(int a,int b){Test::x = a; n = b}

（4）除静态数据成员的初始化之外，静态成员遵循类得其他成员所遵循的访问限制，虽然还没有建立对象，但是静态成员已经存在。

（5）Static不是函数类型中的一部分，所以在类声明之外定义静态成员函数时，不使用static。在类中定义的静态成员函数时内联的。

（6）类的任何成员函数都可以访问静态成员。因为静态成员函数没有this指针，所以静态成员函数只能通过对象名（或指向对象的指针）访问该对象的非静态成员。

2.友元函数

（1）友元函数可以存取私有成员，公有成员和保护成员。其实友元函数可以是一个类或函数，尚未定义的类也可以作为友元。

（2）友元函数在类中声明，但是他并不属于类得成员函数，所以可以在类得外面想普通函数一样定义这个函数。

（3）将成员函数作为友元：一个类得成员函数（包括构造函数和析构函数）可以通过使用friend说明为另一个类非友元。

（4）将一个类说明为另一个类的友元：可以讲一个类说明为另一个类得友元，这时整个类得成员函数均具有友元函数的性能。声明形式为：friend class 类名；

3.Const对象

（1）可以造类中使用const关键字定义数据成员和成员函数或修饰一个对象。一个const对象只能访问const成员函数。

（2）常量成员：常量成员包括常量数据成员，静态常数据成员和常引用。静态常数据成员仍保留静态成员函数，需要在类外初始化。常数据成员和常引用只能通过初始化列表来获得初值。

（3）常引用作为函数参数：使用引用作为函数参数，传得是地址。有时希望将参数的值传递给函数使用，并不允许函数改变对象的值，这是可以使用常引用作为参数。

例如：void Display(const double &r)//这样不会破坏实参

（4）常对象：在 对象名前使用const声明常对象，但是声明时必须同时进行初始化，而且不能被更新。

语法：类名 const 对象名（参数表）；//必须进行初始化

（5）常成员函数：可以声明一个成员函数为const函数。一个const对象可以调用const函数，但不能调用非const成员函数。Const放在函数声明之前意味着返回值是常量，但是这不符合语法，必须将关键字const放在参数表之后，才能说明该函数是一个const成员函数。

声明常成员函数的格式如下：类型标示符 函数名 （参数列表）const；

为了保证不仅声明const成员函数，而且确实也定义为const函数，程序员在定义函数时必须重申const声明。

定义格式如下：类型标示符 类名：：函数名（参数列表） const{函数体}const位于函数参数表之后，函数体之前。

也可用内联函数定义const函数格式如下：类型标示符 函数名（参数列表）const{函数体}

注意：在定义成员函数时，函数体之前加上const可以防止覆盖函数改变数据成员值。

4.指向类成员函数的指针

（1）对象是一个完整的实体，c++包含了指向类成员的指针来封装这一对象。可以用指针范文内存中给定类型的任何对象，指向类成员的指针则用来访问某个特定类的对象中给定类型的任何成员。

第六章

1.继承

（1）单一继承的一般形式：class 派生类名:访问控制 基类名{

Private：

成员声明列表

Protected：

成员声明列表

Public：

成员声明列表

}

（2）派生类的构造函数和析构函数：

定义派生类的构造函数：派生类名：：派生类名（参数表0）：基类名（参数表）

{

函数体；

}

注意：构造函数（包括析构函数）是不被继承的，所以一个派生类只能调用他的直接基类的构造函数。当定义派生类的一个对象时，首先调用基类的构造函数，对基类成员进行初始化，然后执行派生类的构造函数，如果某个基类仍是一个派生类，则这个过程递归进行。

（3）派生类的声明关键字protected之后声明的是类的保护成员，保护成员具有私有成员和公有成员的双重角色：对派生类得成员函数而言，它是公有成员，可以被访问；而对其他成员函数而言则仍是私有成员，不能被访问。

（4）访问权限和赋值兼容规则：继承类和基类成员的访问性保持一样。

（5）派生的对象可以赋给基类的对象，派生类的对象可以初始化基类的引用，派生类的对象的地址可以赋给指向基类的指针。

注意：静态成员被继承，继承类和基类共享同一个静态变量。

（6）ias和has-a的区别：

（7）公有继承存取权限表

2.私有派生

（1）通过私有派生，基类的私有和不可访问成员在派生类中是不可访问的，而公有和保护成员这时就成了派生类的私有成员，派生类的对象不能访问继承的基类成员，必须定义公有的成员函数作为接口。

注意：虽然派生类的成员函数可通过自定义的函数访问基类的成员，但将该派生类作为基类再继续派生时，这时即可使用公有派生，原基类公有成员在新的派生类中也将是不可访问的。

（2）保护派生也可使用protected，这种派生都使原来的访问权限降一个级别。

（3）多重继承：

形式:class 类名1：访问控制 类名2，访问控制 类名3，，，，，，访问控制 类名n{定义派生类自己的成员}；

3.作用域分辨符合成员名操作符

（1）作用域分辨操作的一般形式如下：类名：：标示符

”类名“可以是任一类和派生类名，“类标示符”是该类中生命的任一成员。

（2）派生类支配基类的同名函数

基类的成员和派生类新增的成员都有类作用域，基类再外层，派生类在内层。如果派生类定义类一个和基类成员函数同名的新成员函数（因为参数不同属于重载，所以这里是指具有相同参数表的成员函数），派生类的新成员函数就覆盖了外层的同名成员函数。在这种情况下，直接使用成员名只能访问派生类的成员函数，只要使用作用域分辨，才能访问基类的同名成员函数。

（3）由于二义性，一个类不能从同一个类中直接继承最多一次。

注意：如果必须这样，可以使用一个中间类。二义性检查是在访问权限检查之前进行的。因此，成员的访问权限不能解决二义性问题.那么如何解决二义性问题，使用作用域分辨符进行存取。

第七章

1.类模板

（1）将一些数据类型从类中分离出来形成的一个通用的数据类型T，并为这个数据类型T设计一个操作集，在编译器编译时与特定的类型联系起来。T不是类，天擦很难过称之为类模板。

（2）类模板的成分及语法：class在这里是“任意内部类型或用户定义类型”，T可能是任意结构或类。类模板的一般声明形式：template<类模板参数> class 类名{类体}；

（3）类模板的对象：类名<模板实例化参数类型> 对象名（构造函数实参列表）

；

类名<模板实例化参数类型> 对象名；、、默认或者无参构造函数

（4）在类体外面定义成员函数时，必须用template重写类模板声明。一般形式如下：template<模板参数>

返回类型 类名<模板类型参数>：：成员函数名（函数参数列表）{//函数体}

（5）<模板类型参数>是指template的<>内使用class（或typename）声明的参数，构造函数和析构函数没有返回类型。

（6）类模板的派生和继承：类模板也可以继承，继承的方法与普通的类一样。声明模板继承之前，必须重新声明类模板。模板类的基类和派生类很复杂。

2.向量与泛型算法

（1）在数组生存期内，数组的大小事不会改变的。向量是一位数组的类版本，它与数组相似，其中的元素项是连续存储的，它他和数组的不同的是：向量中存储元素的多少可以在运行中根据需要动态地增长和缩小。向量是类模板，具有成员函数。

（2）定义向量列表：向量（vector）类模板的定义在图文件vector中，他定义四种构造函数，用来定义由各元素组成列表：length表示长度，type表示数据类型，name表示对象名,定义列表如下：

Vector<type>name;//定义type的向量表

Vector<type>name(length);//定义具有length哥type的向量，元素初始化为0

Vector<type>name(length a);//定义具有length个type的向量元素初始化为a

Vector<type>name1(name)；//使用已定义的向量name定义name1

（3）不能使用列表初始化向量，但可以先初始化一个数组，然后把数组的内容复制给向量。例如：int IA[10] = {1，98,1,20,152,20,48,10,14,30}；

Vector<int >VB(IA,IA+10)

IA是数组名，代表数组的起始地址。IA+10是VB的结束标志位，因为向量自动产生 一个结束标志。

（4）泛型指针：向量具有指示第一个元素的标记begin和指示结束的标记end所指元素。当元素部位空是，算法首先会作用于begin所指元素，并将begin前进一个位置。

（5）在向量中，泛型指针是在底层指针的行为之上提供一层抽象化机制，取代程序原来的“指针直接操作方式”。假设用T表示向量的参数化数据类型，iterator在STL里面是一种通用的指针，它在向量中的作用相当于T*.用 iterator什么向量的一般形式：

Vector<type>::reverse_iterator 指针名；

逆向向量泛型指针使用reverse—iterator，声明方法如下：

Vector<数据类型>：：reverse_iterator 指针名

（6）使用typedef可以使声明或定义泛型的手续简单易懂，例如下面泛型指针P：iterator p;

（7）向量的数据类型向量除了可以使用基本数据类型之外，还可以使用构造类型，只要符合构成法则即可。

3.向量最基本的操作方法

（1）访问向量容量的方法：

Size（）：向量中当前已经存放的对象个数。

Max_Size（）：返回向量中可以容纳最多对象的个数，一般式寻址空间所容纳的对象的个数。

Capacity（）：返回无需再次分配内存就能容纳的对象个数。他的初始值就是程序员最开始申请的元素个数。它在原来的基础上自动翻倍扩充空间。

Max_size >= capacity() >= size()

（2）访问向量中对象的方法

Front():返回向量中第一个对象

Back（）：返回想了中的最后一个对象

Operator[]（size_type，n）：返回向量中第n+1个对象

（3）在向量中插入对象的方法

Push_back（const T&）：向向量尾部插入一个对象

Insert（iterator it，const T&）：想it所指的向量位置前插入一个对象

Insert（iterator it，size_type n，const T&X）：想it所指向量位置前插入n哥值为X的对象。

（4）在向量中删除对象的方法

Pop_back（const T&）：删除向量中最后一个对象。

Erase（iterator it）：删除it所指向的容器对象。

Clear（）了删除向量中所有的对象，empty（）返回true值。

第八章

一： 动态联编中的复制兼容性及名字支配规律

（1）对象的内存地址空间中只包含数据成员，并不存储有关成员函数的信息。这些成员函数的地址翻译过程与其对象的内存地址无关。

（2）声明的基类指针只能指向基类，派生类只能指向派生类他们的原始类型决定他们只能调用各自的同名函数。除非派生类没有基类的同名函数。

二：动态联编的多态性

（1）使用关键字virtual声明的函数，将这种函数称为虚函数。当编译系统含有虚函数时，将为他建立一个虚函数表，表中的每一个元素都指向一个虚函数表的指针。此外，编译系统也为类增加一个数据成员，这个数据成员是一个指向该虚函数表的指针，通常称为vptr。

（2）派生类嫩继承基类的虚函数表，而且只要是和基类同名（参数也相同）的成员函数，无论是否使用virtual声明，他们搜自动成为虚函数。如果继承类没有改写继承基类的虚函数，则函数指针调用基类的虚函数。如果派生类改写了基类的虚函数，编译系统将重新为派生类的虚函数建立地址，函数指针会调用该写过的虚函数。

（3）一旦基类定义了虚函数，该基类的派生类中的同名函数也自动称为虚函数。

三：虚函数实现多态的条件

（1）官架子virtual指示c++编译器对调用虚函数进行动态连编。这种多态性是程序运行到需要的语句出才动态确定的，所以称为运行时的多态性。不过使用虚函数并不一定产生多态性，也不一定使用动态联编。

（2）产生多态性有如下3哥前提：

1.类之间的继承关系满足赋值兼容性规则。

2.改写同名虚函数。

3.根据赋值兼容性规则使用指针。

（3）在构造函数和析构函数中调用虚函数采用静态连编，即他们所调用的虚函数是自己的类或基类中定义的函数，但不是任何在派生类中定义的虚函数。

（4）如果基类的析构函数为虚函数，则在派生类中未定义析构函数时，编译器所生成的析构函数也为虚函数。

四：纯虚函数与抽象类

（1）纯虚函数的一般形式如下：

Class 类名

{

Virtual 函数类型 函数名（参数类表） = 0；

}

（2）一个类可以说明多个纯虚函数，包含有虚函数的类称为抽象类。一个抽象类只能作为基类来派生类新类，不能说明抽象类的对象。

（3）从一个抽象类派生的类必须提供纯虚函数的实现代码，或在该派生类中仍将它说明为纯虚函数，否则编译器将给出错误信息。这说明了纯虚函数的派生类仍是抽象类。如果派生类中给出了基类所有纯虚函数的实现，则该派生类不再是抽象类。

（4）抽象类至少包含一个虚函数，而且至少有一个虚函数是纯虚函数，以便将他与空的虚函数区分开来，下面是两种不同的方法：

Virtual void area（） = 0；

Virtual void area（）{}；

（6）在草原函数内可以钓鱼纯虚函数。因为没有为纯虚函数定义代码，所以在构造函数和析构函数内调用一个纯虚函数将导致程序运行错误。

五.多重继承和虚函数

（1）多重继承可以视为多个单一继承的组合，因此，分析多重继承情况下的虚函数调用与分析单一继承有相似之处。

（2）在派生类中，当一个指向基类成员函数的指针指向一个虚函数，并且通过指向度意向的基类指针（或引用）访问这个虚函数时，仍发生多态性。

第九章

一：重载对象的赋值运算符

（1）编译器在默认情况下为每个类生成一个默认的赋值操作，用于同类的两个对象之间相互赋值。默认的含义是逐个赋值，即将一个对象的成员赋值，即将一个对象的成员函数赋值给另一个对象的相应的成员，这种赋值方式对于有些类可能是不正确的。

（2）c++的关键字operator和运算符一起使用就表示一个运算符函数。

（3）运算符重载的实质:运算符的重载的实质就是函数重载，要重载某个运算符只要重载某个相应的函数即可。

（4）插入符（<<）的一般形式如下：

ostream &operator<< (ostream & output,类名 & 对象名)

{。。。。。//函数代码

return output;//output是类ostream对象的引用，他是cout的别名，即ostream&output = cout。

}

（5）提取符的一般形式如下：

Istream &operator >>(istream &input,类名 & 对象名)

{。。。。。。//函数代码

Return input；//input是类istream对象的引用，它是cin的别名，即istream&input = cin。调用参数时引用cin（即cin的函数）

}

（6）另外提取符函数需要返回新的对象值，所以应该使用引用，即“类名&对象名”，不能使用“类名 对象名”,插入符不改变对象的值。