C++摘要

▲函数的重载条件:函数名相同,参数类型和（或）参数个数不同.

下面两种情况不能构成函数重载:

1.只有返回类型不同

int fun();

void fun();

2.参数混淆

int fun(int a,int b=2);

int fun(char a);

 

▲变量的引用

引用可看作是变量的别名,且必须在定义时初始化.

int a;

int &b=a;     //变量b引用了a,b和a的内存地址相同

b=5;            //a和b都是5

 

▲指向常量的指针和指针常量

指向常量的指针可以更改指向的地址，不能改变指向地址所表示的内容。

const int *a;      //定义指向常量的指针，也可写成int const *a

int b,c;

b=1;

c=2;

a=&b;

*a=3;           //错误，不能改变指向地址所表示的内容

a=&c;           //正确，可以更改指向的地址

指针常量能够更改指向地址所表示的内容，不能改变指向的地址，且必须在定义的时候初始化。

int * const d=&b;    //定义指针常量

d=&c;                     //错误，不能改变指向的地址

*d=3;                     //正确，可以更改指向地址所表示的内容

 

 

▲权限关键字   public,private,protected

public:无限制

protected:对象内部和继承对象内部可见

private:仅对象内部可见

 

 

▲struct内成员缺省为public，class内成员缺省为private，除此之外在c++中struct和class是通用的.

 

▲构造函数没有返回值,函数名与类名相同,可重载构造函数,实例化对象时由系统自动调用不带参数的构造函数.

当希望系统调用带有参数的构造函数时

class cls

{

   cls(int a,int b)     //构造函数带有参数

   {

    ...

   }

} ;

cls mycls(1,2);       //1,2传递给构造函数

 

▲析构函数 没有参数和返回值,函数名为~类名,对象消亡时由系统自动调用析构函数,每个类只能有一个析构函数.

 

▲this指针:类所实例化的每一个对象都隐含有一个this指针,this指针指向对象自身,由系统指定.例如在对象中a=1等同于this->a=1

this指针的一个用法是,当成员函数的参数名与成员数据名相同时,通过this->指定成员数据,避免混淆. 

class cls

{

public:

   int a,b;

   cls(int a,int b)      // 参数名与成员数据名相同

   {

       this->a=a;

       this->b=b;

   }

} ;

 

▲类的继承      子类:继承方法 父类

class a

{

...

};

class b : public a     //子类b继承父类a

{

...

};

 

▲继承方法

public :父类中public,protected,private被子类继承为public,protected,NULL

protected:父类中public,protected,private被子类继承为protected,protected,NULL

private:父类中public,protected,private被子类继承为private,private,NULL

 

▲子类的构造与析构

子类实例化对象时,首先执行父类构造函数,再执行子类构造函数.

给父类构造函数传递参数的方法如下:

 

class a

{

public:

   a(int x,int y)      //系统默认调用不带参数的构造函数,子类应传递参数告诉系统执行带参构造函数

   {

       ...

   }

} ;

 

 

class b : public a

{

public:

   b():a(1,3)       //向父类构造函数传递参数

   {

    ...

    }

};

 

子类实例化对象消亡时,首先执行子类的析构函数,再执行父类的析构函数.

 

▲类中常量的初始化

构造函数:常量名(初始值)

class a

{

public:

   const int b;

   cls():b(22)      //常量b被22初始化,多个常量可用,分隔

   {

       ...

   }

} ;

 

▲作用域标识符::

子类中出现与父类中名字相同的变量或函数时, 子类的变量或函数会将父类中的同名变量或函数覆盖.

若要在子类中访问父类中的同名变量或函数应使用作用域标识符::

 

class a

{

public:

    int x;

    void fun()

    {

     ....

    }

};

 

class b : public a

 

{

public:

    int x;

    void fun()

    {

     ....

    }

    void test()

    {

         cout<<x<<endl;            //子类的x

         cout<<a::x<<endl;       //父类的x

         fun();                            //子类的fun函数

         a::fun();                       //父类的fun函数

    }

};

 

▲虚函数

class c
{
public:
     void fun()
    {
        cout<<"this is c"<<endl;
    }
};

class d:public c
{
public:
    void fun()
    {
         cout<<"this is d"<<endl;
    }

};

main()
{
    c* cc;
    d dd;
    cc=&dd;        //将子类对象的地址传递给指向父类对象的指针

    cc->fun();     //输出为 this is c
}

希望的结果是this is d,为此需要使用虚函数,将class c改成如下:

class c
{
public:
     virtual void fun()      //虚函数
    {
        cout<<"this is c"<<endl;
    }
};

此时main运行结果为this is d.且子类中的fun()不管有无virtual关键字也成为虚函数.

必须先使用基类指针指向子类的对象，然后使用基类指针调用虚函数,根据不同的类对象,调用其相应的函数,若子类中没有该函数则调用父类的.虚函数只能出现在类中.

 

▲纯虚函数

没有函数体的虚函数,形如virtual void fun()=0;

含有纯虚函数的类叫抽象类且不能实例化对象只能作为父类,可在子类中具体实现该函数体,用子类实例化对象.

class a
{
public:
     virtual int fun(int x)=0;      //纯虚函数
};

class b:public a
{
public:
     void int fun(int x)        //实现纯虚函数体
     {
          cout<<x<<endl;

          return x;
     }
};

 

main()

{

    a aa;       //错误,a不能实例化对象

    b bb; 

}

 

▲在类的定义外定义成员函数

返回类型 类名::函数名(参数)

{

....

}

如下:

class a 
{
public:
     int fun(int x);      //仅声明
};

 

int a::fun(int x)        //对类a中函数的定义

{

 ...

}

 

▲静态成员变量

静态成员变量的所有者是类本身和类实例化的对象，可用于多对象共享数据。静态成员变量不能在类定义里或构造函数中或头文件中初始化，只能在类定义外的源文件中初始化。

class a 
{
public:

     static int x;
     ...
};

int a::x=1;      //类定义外初始化静态成员变量  

 

▲静态成员函数

静态成员函数不属于对象，只属于类本身， 因此他没有this指针，同时不依赖类所实例化的对象就可直接使用的类中成员函数

static 返回类型 函数名(变量名)

静态函数的声明和定义必须在类的定义中，且静态函数不能访问类中非静态的成员变量

class a 
{
public:

     static int x;

     int y;
     static int fun(int x)

     {

      cout<<x;      //正确

      cout<<y;      // 错误，不能访问非静态的成员变量

     }
};

int a::x=1;

 

main()

{

a::fun();     //  不依赖类所实例化的对象， 直接使用的类中成员函数

}