c++面向对象程序设计-类和对象（基础）

傷城~ 2022-01-26 10:25 457阅读 0赞

**目录**

类的数据成员和成员函数

在类体之外定义成员函数

内联函数

对象的创建

类成员的访问

构造函数和析构函数

复制构造函数

对象指针

this指针

静态类成员

静态数据成员的声明，初始化与访问

静态成员函数

动态内存分配

## 类的数据成员和成员函数 ##

class 类名
    {       //类体
        private:
            //<私有数据成员，私有成员函数>
            int s;    //数据成员
            void print(){cout<<"成员函数";}
        public:
            //<公有数据成员，公有成员函数>
        protected:
            //<保护型数据成员，保护型成员函数>
    }

*  私有成员（private）数据只能在类中的成员函数中使用，私有成员函数只能被类中其他成员函数调用，私有成员不能通过对象使用。类成员默认权限为private。
 *  公有成员（public）可以在类中使用，也可以通过对象直接使用。
 *  保护型成员（protected）可以在类体中使用，也可以在派生类中使用，但不能在其他类通过对象使用。

### 在类体之外定义成员函数 ###

类体中只保留成员函数的原型声明。也称为外联函数。可以访问操作私有成员数据。

返回类型 类名 ::成员函数名(参数表){函数体}

### 内联函数 ###

程序编译时将函数代码插入函数调用处。

1.  在类体中定义函数体的成员默认为内联函数。
2.  可以使用inline关键字定义内联函数（在类体之外定义函数体的成员函数）

class Sum
    {
        private:
            int s;
        public:
            int m;
            void change(){s=0;}
            void setSum(int x);  //成员函数的原型声明
            void print();
    };    //这里有一个分号
    Sum :: setSum(int x)  //::为作用域解析运算符，实现成员函数
    
    {
        s=x;
    }
    inline void Sum :: print(int x)
    {
        s=x;
        cout<<"s的值为"<<s;
    }

## 对象的创建 ##

对象是类的实例化，定义一个类的对象：类名 对象名;

### 类成员的访问 ###

*  对象名.公有数据成员名;
 *  对象名.公有成员函数名(实参表);

Sum a;
    a.m=3;
    a.print(8);

## 构造函数和析构函数 ##

*  构造函数作用在对象被创建时使用特定的值构造对象，将对象初始化一个特定的状态。名字必须与其所属的类名相同，并声明为公有成员函数，且没有任何类型的返回值。
 *  作为类的一个成员函数，具有一般成员函数所有的特性，可以访问类的所有数据成员，可以是内联函数，可以带参数（参数在定义对象是带上），还可以带默认的形参值。
 *  可以重载，重载的构造函数之间以所带参数的个数或类型的不同而区分。

class Sum
    {
        private:
            int m;
        public:
            Sum(){m=0;}    //没有返回值
            Sum(int x);  //成员函数的原型声明
            ~Sum(){cout<<"调用析构函数\n";}
    };    //这里有一个分号
    Sum :: Sum(int x)
    {
        m=x;
    }
    void main(){
        Sum a1;
        Sum a2(10);
    }

析构函数作用在类对象生命周期结束时，清理和释放类对象所占用的系统资源。析构函数有所属类同名，函数名前加一个逻辑非运算~，表示构造函数的逆。一个类中只能定义一个析构函数。

### 复制构造函数 ###

具有一般构造函数所有的属性，创建新对象时被调用，其形参是本类的对象的引用。作用是用一个存在的对象初始化另一个正创建的同类对象，将已知对象的数据成员的值复制给另一个正在创建的另一个同类的对象。

*  函数名与类名同名（也是一种构造函数），不指定返回类型。
 *  只有一个参数，并且是对某对象的引用。
 *  每个类都必须有一个复制初始化构造函数（若没有说明，编译系统会自动生成一个）。

class Sum
    {
        private:
            int s;
        public:
            void print(){cout <<"s为："<
            Sum(int x,int y){s=x*y;}
            Sum(Sum &p){s=2*p.s;};    //没有返回值
            ~Sum(){cout<<"调用析构函数\n";}
    };
    void main(){
        Sum a1(2,3);
        Sum a2(a1);
        a2.print();
    }

## 对象指针 ##

指向对象的指针，对象指针就是存放该对象地址的变量。

类名 *对象指针名;

用指针访问对象成员时用“->”运算符：对象指针名->类成员名;或(\*对象指针名).类成员名;

### this指针 ###

类成员变量和类成员函数相同时用"this->"区别，指向调用成员函数对象的一个特殊的指针。

class Test
    {
        private:
        int x;
        public:
        int m;
        void setX(int m){this->m=m;}
    }
    void main()
    {
        Test t,*p;
        p=&t; //通过地址赋值，使指针p指向对象t
        t.setX(10);
        cout<<"通过指针访问的m的值："<<p->m<<endl;
    }

### 静态类成员 ###

某类所有对象的静态数据成员都共用同一个存储空间，即静态数据成员被类的所有对象共享。

1.  static声明的静态成员在编译时分配存储空间，直到整个程序执行完才撤销。
2.  static静态成员的初始化是在编译时进行的，一般在定义static静态成员时要给出初始值。

### 静态数据成员的声明，初始化与访问 ###

static 数据类型 静态数据成员名;
    数据类型 类名::静态数据成员名=初值;    //必须在类外初始化
    类名::静态数据成员名;    //在类外只能通过类名访问(被声明为私有成员时，只能在类内直接引用)

#include
    using namespace std;
    class Student
    {
        private:
            int id;
            static int sum;
        public:
            Student(int id){this.id=id;sum++;}
            void printSum(){cout<<"学生总数："<<sum};
    }
    int Student :: sum=0;
    void main()
    {
        Student stu1(1),stu(2),stu(3);
        stu1.printSum();
    }

### 静态成员函数 ###

可以直接引用该类的静态数据和成员函数，不能引用非静态数据成员（要引用必须通过对象名来引用）。公有的静态函数成员可以通过类名或函数名来调用（非静态的只能通过对象名调用）。定义静态成员函数：

static 返回类型 函数名(参数表){函数体}

引用：类名::静态成员函数名（实参表） 或 对象名.静态成员函数名（实参表）

1.  静态成员函数无this指针
2.  访问的基本上是静态数据成员或全局变量
3.  在调用静态成员函数的前面，必须有对象名或类名

#include
    using namespace std;
    class Student
    {
        private:
            int id;
            static int sum;
        public:
            Student(int id){this.id=id;sum++;}
            void static printSum(){cout<<"学生总数："<<sum;
    }
    int Student :: sum=0;
    void main()
    {
        Student stu1(1),stu(2),stu(3);
        stu1.printSum();
        Student ::printSum();
    }

## 动态内存分配 ##

new运算实现动态内存分配，其创建的对象是一个指向该区域的地址指针变量。

类名 *指针对象名;
    指针对象名 = new 构造函数(参数列表);

运算符delete用来删除由new建立的对象，释放指针所指向内存的空间，此时该对象的析构函数将被调用。

delete 指针对象名;
    
    class Student
    {
        private:
            int id;
        public:
            Student(int id){this.id=id;}
            void static printSum(){cout<<"学生id："<<id;
            ~Student(){cout<<"对象将被销毁";}
    }
    void main()
    {
        Student *p;
        p=new Student(1);
        p->printSum();
        delete p;    //释放对象调用析构函数
    }

基本数据类型动态分配内存区域

指针变量 = new 数据类型(初值列表);
    delete 指针变量;

int *pi;
    pi=new int;
    *pi=3;
    cout<<pi;    //pi为3的地址
    cout<<*pi; //*pi为int数据的值
    为数组对象动态分配内存区域
    指针变量 = new 对象类型名[数组容量];
    delete[] 指针变量;
    
    int *p;
    p=new int[3];
    delete [] p;