C++复习总结（涵盖所有C++基本考点）！

 

               这几天一直忙考试了，随笔也没什么好写的东东，昨天考电路也挺痛苦的，没有复习好，仓促上阵，很多不会，拿不准。

还好我们这期末成绩是按平时分+考试分，要不然铁挂。不过总算熬过了一科。8号考C++，所以我就干脆把所有C++考点总结一下

，凑篇随笔发上来。我会以知识点的形式总结，方便后人参考。请看正文：

*********************************C++复习总结************************************

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

尊重作者产权，人人有责。

 

*******************************************************************************