目录

一、类与对象的思想

1、类和对象的概念

2、类的访问控制

3、类中的元素说明

4、类的实际使用

二、对象的构造和析构函数

1、构造函数

2、构造函数的重载与调用

3、拷贝构造函数

4、深度拷贝

5、默认构造函数

6、析构函数

7、匿名对象

8、对象的动态创建和释放

9、构造函数的形参初始化列表

三、静态成员变量和静态成员函数

1、静态成员变量

2、静态成员函数

四、友元函数与友元类

1、友元函数

2、友元类

---

一、类与对象的思想

面向对象的特点：封装、继承、多态

面向对象编程的特点：

（1）易维护：可读性高，即使改变了需求，由于继承的存在，只需要对局部模块进行修改，维护起来非常方便，维护的成本也比较低。

（2）质量高：可以重用以前项目中已经被测试过的类，使系统满足业务需求从而具有更高的质量

（3）效率高：在软件开发时，根据设计的需求要对现实世界的事物进行抽象，从而产生了类

（4）易扩展：由于继承、封装、多态的特性，可设计出高内聚、低耦合的系统结构，使系统更加灵活、更容易扩展，而且成本也比较低。

1、类和对象的概念

c++是一门面向对象的语言，理解c++，首先要理解类和对象

c++中的类可以看成c语言中的结构体的升级版，，结构体是一种构造类型，可以包含若干个成员变量，成员变量的类型可以不同。

关于class（类）的几点说明：

（1）类的定义的最后有一个分号，它是类的一部分，表示类定义结束，不能省略。

（2）一个类可以创建多个对象，每个对象都是一个变量

（3）类是一种构造类型，大小的计算方法和struct一样，需要字节对齐

（4）类成员变量的访问方法：通过 .或者->来访问

（5）成员函数是类的一个成员，出现在类中，作用范围由类来决定，而普通函数是独立的，作用范围是全局或者某个命名空间

struct ：内部默认是共有权限，结构体外部可以访问其内部成员

class：内部默认是私有权限，类的外部不能直接访问内部成员；可以手动声明为共有权限;

2、类的访问控制

public：公有属性，凡是在它下面声明的变量和函数，都可以在类的内部和外部访问

private:私有属性，凡是在它下面声明的变量和函数，只能在类的内部访问

protected:保护属性，凡是在它下面声明的变量和函数，只能在类的内部以及派生类（子类）中访问

3、类中的元素说明

类中有成员变量（属性）、成员函数（方法）；

类可以创建对象；

4、类的实际使用

举例：创建一个学生类（成员变量：年龄、姓名；成员方法：年龄输入、年龄输出）

注意：一个类中必须有输入与输出

头文件：student.h（含类创建）

//student.h#ifndef _STUDENT_H_#define _STUDENT_H_#include <iostream>using namespace std;class Student{    public:        int GetAge();   //声明类的成员函数，在函数的其它地方实现        int SetAge(int age);    private:        int m_age;        char m_name[32];};#endif

方法体：student.cpp

//Student.cpp#include "student.h"int Student::GetAge(){    return m_age;}int Student::SetAge(int age){    m_age = age;}

主函数：main.cpp

//main.cpp#include "student.h"int main(int argc, char const *argv[]){    Student s1;    s1.SetAge(18);    cout<<s1.GetAge()<<endl;    return 0;}

练习1：设计一个立方体类，求出立方体的面积（2ab + 2ac + 2bc）和体积(a*b*c)，并且判断两个立方体是否相等

要求： 私有成员变量：长宽高

成员函数（方法）：求面积，求体积，设置长宽高

全局函数：判断两个立方体是否相等

头文件：cube.h（含类创建）

#ifndef _CUBE_H_#define _CUBE_H_#include <iostream>using namespace std;class Cube{private:    int m_length;    int m_wide;    int m_high;public://求面积    int GetArea();//求体积    int GetVolume();//设置长宽高    void SetCube(int length,int wide,int high);//获取长度    int GetLength();//获取高度    int GetHight();//获取宽度    int GetWide();};bool CubeIsEqual(Cube c1, Cube c2);#endif

方法体：cube.cpp

#include "cube.h"int Cube::GetArea(){    int MyArea = 2*m_high*m_length + 2*m_high*m_wide + 2*m_length *m_wide;    return MyArea;}int Cube::GetVolume(){    return m_high*m_length*m_wide;}void Cube::SetCube(int length,int wide,int high){    m_length = length;    m_wide = wide;    m_high = high;}//获取长度int Cube::GetLength(){    return m_length;}//获取高度int Cube::GetHight(){    return m_high;}//获取宽度int Cube::GetWide(){    return m_wide;}bool CubeIsEqual(Cube c1, Cube c2){    if(c1.GetHight() == c2.GetHight() && c1.GetLength() == c2.GetLength() && c1.GetWide() == c2.GetWide())    {        return true;    }    else    {        return false;    }}

主函数：main.cpp

#include "cube.h"int main(int argc, char const *argv[]){    Cube c1,c2;   //创建对象    c1.SetCube(1,2,3);    c2.SetCube(1,3,2);    cout<<"c1的面积是："<<c1.GetArea()<<endl;    cout<<"c2的面积是："<<c2.GetArea()<<endl;    cout<<"c1的体积是："<<c1.GetVolume()<<endl;    cout<<"c2的体积是："<<c2.GetVolume()<<endl;    if(CubeIsEqual(c1,c2))    {        cout<<"c1 = c2"<<endl;    }    else    {        cout<<"c1 != c2"<<endl;    }    return 0;}

练习2：设计一个圆形类和一个点类，计算点和圆的关系

要求：

1> 点类 属性：横坐标和纵坐标

方法：点和点之间的距离计算

           设置横坐标，纵坐标

2> 圆形类 属性：半径 ，圆心 、

方法：计算点和圆的关系

           设置半径和圆心

头文件：circle.h（含类创建）

#ifndef _CIRCLE_H_#define _CIRCLE_H_#include <iostream>using namespace std;class Point{private:    int m_x;    int m_y;public:    void setXY(int x,int y);    int Distance(Point &p);    };class Circle{    private:        Point m_center;        int m_r;    public:        void SetC(int x,int y,int r);        bool Judge(Point &p);};#endif

方法体：circle.cpp

#include "circle.h"void Point::setXY(int x,int y){    m_x = x;    m_y = y;}int Point::Distance(Point &p){    int dis = (p.m_x - m_x)*(p.m_x - m_x) + (p.m_y - m_y) *(p.m_y - m_y);    return dis;}void Circle::SetC(int x,int y,int r){    m_center.setXY(x,y);    m_r = r;}bool Circle::Judge(Point &p){    if(p.Distance(m_center) >= m_r *m_r)    {        return true;    }    else    {        return false;    }}

主函数：main.cpp

#include "circle.h"int main(int argc, char const *argv[]){    Point p;    p.setXY(0,3);    Circle c1;    c1.SetC(0,0,2);    if(c1.Judge(p))    {        cout<<"点在圆上或者圆外"<<endl;    }    else    {        cout<<"点在圆内"<<endl;    }    return 0;}

二、对象的构造和析构函数

1、构造函数

在c++中，由一种特殊的成员函数，名字和类名相同，没有返回值，不需要用户显示调用（用户也不能调用），而是在创建对象的时候自动调用。 这种函数我们称为构造函数 关于构造函数：

1.函数名必须和类型相同

2.不能有返回值，函数体不能有return语句

3.构造函数在定义对象时会自动调用，不需要手动调用

#include <iostream>#include <cstdlib>using namespace std;class Array{    private:        int *m_data;   //数组的起始地址        int m_size;    public:        Array();  //无参构造函数，函数名和类名一致，没有返回值        void SetVal(int Index,int Val);        int GetVal(int Index);        ~Array();  //析构函数，函数名为：~类名 ,没有返回值，没有参数};Array::Array(){    cout<<"Array的无参构造函数"<<endl;    m_size = 5;    m_data = (int *)malloc(sizeof(int) *m_size);}Array::~Array(){    cout<<"Array的析构函数"<<endl;    if(m_data != NULL)    {        free(m_data);        m_data = NULL;    }}int main(int argc, char const *argv[]){    Array a1; //创建对象，会自动调用构造函数    return 0;}

2、构造函数的重载与调用

和普通函数一样，构造函数是允许重载的，一个类可以有多个重载的构造函数，在创建对象时根据传递实参来判断调用哪一个构造函数

#include <iostream>#include <cstdlib>using namespace std;class Array{    private:        int *m_data;   //数组的起始地址        int m_size;    public:        Array();  //无参构造函数，函数名和类名一致，没有返回值        Array(int s);  //有参构造函数        Array(int s,int z);  //有两个参数的构造函数        ~Array();  //析构函数，函数名为：~类名 ,没有返回值，没有参数};Array::Array(){    cout<<"Array的无参构造函数"<<endl;    m_size = 5;    m_data = (int *)malloc(sizeof(int) *m_size);}Array::Array(int s)  //有参构造函数{    cout<<"Array的有一个参数的构造函数"<<endl;    m_size = s;    m_data = (int *)malloc(sizeof(int) * m_size);}Array::Array(int s,int z)  //有两个参数的构造函数{    cout<<"Array的有两个参数的构造函数"<<endl;    m_size = s;    m_data = (int *)malloc(sizeof(int) * m_size);}Array::~Array(){    cout<<"Array的析构函数"<<endl;    if(m_data != NULL)    {        free(m_data);        m_data = NULL;    }}int main(int argc, char const *argv[]){    //Array a1(6);    //括号法    //Array a2(1,2);  //调用两个参数的构造函数    //Array a1 = 7;   //等号法    Array a3 = (1,2);  //逗号表达式    return 0;}

3、拷贝构造函数

（1）概念

用一个现有的对象去初始化另一个对象

声明：Array(const Array &a); //拷贝构造函数

（2）拷贝构造函数的调用时机

1.用一个对象初始化另一个的对象

Array a1(a3);

Array a1 = a3;

Array a1 = Array(a3);

2.当函数的形参是一个对象时，例如：

void print(Array a)  //Array a = a1;

{    

        a.GetVal(1);

}

3. 函数的返回值是一个对象

Array& Func()

{    

        Array a1;    

        return a1;

}

#include <iostream>#include <cstdlib>using namespace std;class Array{    private:        int *m_data;   //数组的起始地址        int m_size;    public:        Array();  //无参构造函数，函数名和类名一致，没有返回值        Array(const Array &a);  //拷贝构造函数        ~Array();  //析构函数，函数名为：~类名 ,没有返回值，没有参数};Array::Array(){    cout<<"Array的无参构造函数"<<endl;    m_size = 5;    m_data = (int *)malloc(sizeof(int) *m_size);}Array::Array(const Array &a){    cout<<"Array的拷贝构造函数"<<endl;}Array::~Array(){    cout<<"Array的析构函数"<<endl;    if(m_data != NULL)    {        free(m_data);        m_data = NULL;    }}void print(Array a)  //Array a = a1;{    a.GetVal(1);}Array& Func(){    Array a1;    return a1;}int main(int argc, char const *argv[]){    //Array a1;   // Array a2 = a1;    //print(a1);    Array a2 = Func();    return 0;}

4、深度拷贝

深度拷贝：数据和内存空间都要拷贝；

Array::Array(const Array &a)   //深拷贝{    cout<<"Array的拷贝构造函数"<<endl;    m_size = a.m_size;    m_data = (int *)malloc(sizeof(int) * m_size);    for(int i = 0 ; i < m_size;i++)    {        m_data[i] = a.m_data[i];    }}

5、默认构造函数

当使用者没有提供构造函数，系统会提供默认构造函数；

当使用者提供了构造函数：

（1）提供了无参构造函数，编译器将不会再提供默认无参构造函数

（2）提供了有参构造函数，系统将不再提供无参构造函数

#include <iostream>using namespace std;class Demo{public:    /*Demo()  //一旦提供了无参构造函数，编译器将不会再提供默认无参构造函数    {        cout<<"无参构造函数"<<endl;    }*/    Demo(int a)    //一旦提供了有参构造函数，系统将不再提供无参构造函数    {        cout<<"DemO的有参构造函数"<<endl;    } };int main(int argc, char const *argv[]){    Demo d;  //会提供默认的构造函数    Demo d1 = d;  //会提供默认的拷贝构造函数    return 0;}

6、析构函数

创建对象时系统会调用构造函数进行初始化工作，同样，销毁对象时系统也会自动调用一个函数进行清理工作，如释放分配的内存、关闭打开的文件等，这个函数就是析构函数。

格式：

~类名（）; //析构函数

注意：析构函数没有参数，不能被重载，一个类只能有一个析构函数，如果用户没有定义析构函数，编译器会提供默认的析构函数。

#include <iostream>#include <cstdlib>using namespace std;class Array{    private:        int *m_data;   //数组的起始地址        int m_size;    public:        Array();  //无参构造函数，函数名和类名一致，没有返回值        Array(const Array &a);  //拷贝构造函数          ~Array();  //析构函数，函数名为：~类名 ,没有返回值，没有参数};Array::~Array(){    cout<<"Array的析构函数"<<endl;    if(m_data != NULL)    {        free(m_data);        m_data = NULL;    }}int main(int argc, char const *argv[]){    //Array a1;   // Array a2 = a1;    //print(a1);    Array a2 = Func();    return 0;}

7、匿名对象

类名（）//匿名对象，代码执行完毕，立即释放（不用到return）

#include <iostream>using namespace std;class Test{    public:        Test()        {            cout<<"Test的无参构造函数"<<endl;        }        ~Test()        {            cout<<"Test的有参构造函数"<<endl;        }};int main(int argc, char const *argv[]){    Test();   //匿名对象，本行代码执行完，立即被释放    cout<<"*******************"<<endl;    return 0;}

8、对象的动态创建和释放

new和delete:

#include <iostream>#include <cstdlib>using namespace std;class Test{    public:        Test()        {            cout<<"Test的无参构造函数"<<endl;        }        Test(int a)        {            cout<<"有一个参数的构造函数"<<endl;        }        ~Test()        {            cout<<"Test的有参构造函数"<<endl;        }};int main(int argc, char const *argv[]){    //Test * t1 = (Test *)malloc(sizeof(Test));    //free(t1);    Test *pt = new Test(1);  //会自动调用构造函数    delete pt;       //会自动调用析构函数    return 0;}

9、构造函数的形参初始化列表

使用情形：

//对象的初始化列表：

（1）类对象作为成员变量并且该类没有提供无参构造函数

（2）成员变量为const修饰

#include <iostream>using namespace std;class Date{private:    int m_year;    int m_month;    int m_day;public:       Date(int y,int m,int d)    {        cout<<"Date的有参构造函数"<<endl;        m_year = y;        m_month = m;        m_day = d;    }};//对象的初始化列表：1.类对象作为成员变量并且该类没有提供无参构造函数 2.成员变量为const修饰class Student{    private:        const int m_id;        Date birth;    public:    Student(int y,int m,int d,int i):birth(y,m,d),m_id(i)     {        cout<<"Student的有参构造函数"<<endl;    }};int main(int argc, char const *argv[]){    Student s1(1998,5,6,100);    return 0;}

三、静态成员变量和静态成员函数

1、静态成员变量

（1）普通函数可以访问静态成员变量

（2）静态成员变量一定要在类的外部初始化

（3）静态成员变量可以直接通过类名来访问

在c++中，静态成员变量属于某个类，而不属于某个对象，我们可以使用静态成员变量来实现多个对象共享数据的目标

class Student

{

        static int m_num;

};

2、静态成员函数

（1）静态成员函数中只能访问静态成员变量，不能访问普通变量

（2）静态成员函数中的静态成员变量可以通过类名访问

（3）普通成员函数不能通过类名访问

#include <iostream>using namespace std;class Student{    public:        static int count;    private:        int id;    public:        Student()        {            count++;            id = count;        }        int GetCount() //普通函数可以访问静态成员变量        {            return count;           }        static int GetCount1() //静态成员函数        {            return count;    //静态成员函数中只能访问静态成员变量，不能访问普通变量        }};int Student::count = 0;  //静态成员变量一定要在类的外部初始化int main(int argc, char const *argv[]){    Student s1;    Student s2;    cout<<s1.count<<endl;    cout<<s2.count<<endl;    cout<<Student::count<<endl;   //静态成员变量可以直接通过类名来访问    cout<<Student::GetCount1()<<endl;    cout<<s1.GetCount()<<endl;    return 0;}

四、友元函数与友元类

1、友元函数

在当前类的外部定义、不属于当前类的函数也可以在类中声明，但是要在前面加关键字friend, 这样就构成了友元函数。友元函数可以是不属于任何类的非成员函数，也可以是其他类的成员函数。

友元函数可以访问当前类中的所有成员，包括public、protected、private等属性的成员。      

#include <iostream>using namespace std;class Test{    friend void show(Test &t);  //将show函数声明为Test的友元，show可以访问Test的所有成员变量    private:        int m_a;    public:        void set(int a)        {            m_a = a;        }};void show(Test &t){    cout<<t.m_a<<endl;}int main(int argc, char const *argv[]){    Test t1;    t1.set(2);        show(t1);    //通过友元函数可以访问，Test类中的所有成员。    return 0;}

2、友元类

如果将类B声明为类A的友元类，那么类B中的所有成员函数都是类A的友元函数，类B就可以访问类A的所有成员，包括public、protected、private属性成员。

#include <iostream>using namespace std;class A{    friend class B;  //声明B为A的友元，友谊具有单向性，不代表A是B的友元，破坏了他的封装性    private:    int m_a;    public:        void set(int a)        {            m_a = a;        }};class B{    private:        int m_b;    public:        void print(A &a)        {            cout<<"m_a = "<<a.m_a<<endl;        }};int main(int argc, char const *argv[]){    A a1;    a1.set(2);    B b1;    b1.print(a1);   //当B成为A的友元类后，类B的所有成员函数都是A的友元函数，所以通过B的函数    return 0;       //可以访问A中所有成员。}