C++类与对象

Posted on by hackdl

目录

类与对象的基本认识

类和对象的基本概念

类

类的认识

类的定义

类的两种定义方式

类的声明和定义分开

类的声明和定义放在一起

成员变量名的命名规则建议

类的封装

类的访问限定符

类的作用域

对象

类的实例化

类对象的大小

this关键字

this指针的特点

类与对象的基本认识

C语言是面向过程的编程语言，所谓面向过程，即处理好解决一个问题需要的步骤

而C++是面向对象的编程语言，所谓面向对象，即关心需要处理的问题中有多少个整体，每个整体之间有什么关系，通过对象和对象之间的联系交互解决问题

举一个生活实例，一个人洗衣服的方式

  1. 用手洗——需要关注下面的步骤

上面用手洗的方式就是面向过程的步骤，需要考虑到人洗衣服的每一个步骤

结合C语言面向过程，可以得到下面的解题步骤：

    1. 调用拿盆子的函数——函数实现拿盆子
    2. 调用放水的函数——函数实现放水
    3. 调用放衣服的函数——函数实现放衣服
    4. 调用放洗衣粉的函数——函数实现放洗衣粉

主函数中通过上面多个函数的顺序调用完成一系列的动作，如果没有某一个特定的函数，那么将无法完成相应的动作

  1. 用洗衣机洗——关注对象之间的关系

在洗衣服过程中，涉及到人、衣服、洗衣机和洗衣粉四个对象

而整个洗衣服的过程只有：人将衣服放入洗衣机，倒入洗衣粉，启动洗衣机，最后人晾衣服即可

在这个过程中，处理好：人和衣服，人和洗衣机，人和洗衣粉以及洗衣机和衣服之间的关系即可，不需要关注人是如何把衣服放入洗衣机中的步骤，人是如何启动洗衣机的步骤，人是如何放入洗衣粉的步骤以及洗衣机是如何将衣服洗干净的步骤这些细节问题

结合C++的面向对象，可以得到下面的分析：

    1. 人和衣服——人使用衣服中的方法完成拿衣服和晾衣服的动作，但是拿衣服和晾衣服具体是如何实现的与人无关
    2. 人和洗衣机——人使用洗衣机中的方法启动洗衣机，但是洗衣机内部启动的方法具体是如何实现的与人无关
    3. 人和洗衣服——人使用洗衣粉中的方法倒入洗衣粉，但是人不用关心洗衣粉进洗衣机的方法是如何实现的与人无关

总结，C语言中的面向过程指只要涉及到解决问题的主要步骤就需要去实现对应的方法，不论这个方法在C++中是哪一个对象的，而在C++中，每一个对象只需要实现自己的方法，剩下的交给对象之间的交互完成即可

类和对象的基本概念

类

类的认识

在C语言中，结构体中只能定义变量，但是在C++中，结构体可以定义变量和函数

//C语言的单链表
typedef struct SList
{
    int val;
    struct SList* node;
}SList;
//单链表的实现方法
//...

//C++中的单链表
struct SList
{
    int val;
    SList* node;//C++中的结构体属于类的一种，所以可以直接使用类名创建变量
    //单链表的实现方法
    //...

};

但是在C++中，更喜欢用class代表类，struct更多还是结构体，所以上面代码改为

//C++中的单链表
class SList
{
    int val;
    SList* node;
    /服务器托管网/单链表的实现方法
    //...
};

类的定义

在C++中，使用下面的语法进行类的定义

class className
{
    //成员变量

    //实现方法

};//注意不要遗忘分号

在类的定义语法中，class为类定义的关键字，className为类名，{}中的内容为类的主体

类的内容一般称作成员，而类中的变量一般成为成员变量，类中的方法一般称为方法或者成员函数

需要注意的是，成员变量可以出现在成员函数的上方也可以出现在成员函数的下方，因为编译器在寻找成员变量时是将类当做一个整体看待，此时不论是在成员函数的上方还是下方都能寻找到需要的成员变量

类的两种定义方式

类的声明和定义分开

在C++中，如果在大项目中，一般使用类的声明和定义分开的方式，即在头文件中声明，在实现文件中定义，但是需要注意下面的问题：

  1. 因为声明和定义分开处理，所以定义所在的文件需要引入类声明所在的头文件
  2. 当定义需要实现类中声明的方法时将看不到放在头文件中的类的成员变量，此时需要使用域作用限定符指定对应的类

代码实例：

//class_test.h
#pragma once

class Person
{
    //实现方法
    int test();

    //成员变量
    int age = 0;
    int num = 0;
};

//class_test.cpp（方法定义文件）
#include "class_test.h"//需要包含类所在的头文件

int Person::test()//使用域作用限定符指定是哪个类中的方法
{
    return age + num;
}
类的声明和定义放在一起

当项目不够大时，或者只是简单的实现时，可以考虑将类的声明和定义放在同一个文件中，需要注意的是，当成员函数的声明和定义在一起时，编译器可能会当做内联函数处理

class Person1
{
    //实现方法
    int test()
    {
        return age + num;
    }

    //成员变量
    int age;
    int num;
};

成员变量名的命名规则建议

当成员函数的定义在类中时，需要考虑到成员函数的形式参数（局部变量）和成员变量之间的关系

//成员变量命名
class test
{
    int num1;
    int num2;
public:
    int add(int num1, int num2)
    {
        num1 = num1;
        num2 = num2;
        return num1 + num2;
    }
};

#include 
using namespace std;

int main()
{
    test t;
    cout

如果像上面的代码中，成员变量和add函数中的局部变量相同，那么会因为局部优先原则导致成员变量并没有被赋值成功，如下图所示

而如果将成员变量和add函数中的局部变量加以区分，则此时可以成功将局部变量的值存入成员变量中

class test
{
    int _num1;
    int _num2;
public:
    int add(int num1, int num2)
    {
        _num1 = num1;
        _num2 = num2;
        return num1 + num2;
    }
};

#include 
using namespace std;

int main()
{
    test t;
    cout

结果如下图所示：

上面的区分成员变量和形式参数的方式仅供参考，具体以环境要求为主

类的封装

面向对象的三大特性：封装、继承和多态

在C++中，类的封装表示将方法和成员变量进行结合，对外只通过公开的接口与其他对象进行交互

在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用

class Person
{
    //实现方法
    int test();

    //成员变量
    int age = 0;
    int num = 0;
};

在上面的代码中，test函数并没有公开，因为访问权限的问题，所以外部对象将无法使用

类的访问限定符

在C++中，一共有三个访问限定关键字，即private（私有）、protected（受保护）以及public（公开）

在C++中，类的访问权限有下面的特点

  1. public修饰的成员在类外可以直接被访问
  2. protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的，只研究private与protected和public的区别，三者具体细节见后序分析)
  3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止，如果后面没有访问限定符，作用域就到}即类结束
  4. class的默认访问权限为private，struct为public(因为struct要兼容C语言)
//结构体默认是public，而类默认是private
#include 
using namespace std;

struct test
{
    int v服务器托管网al;
    int test1()
    {
        cout

需要访问类中的函数时，可以指定访问权限，使用public后可以在类外访问

#include 
using namespace std;

struct test
{
    int val;
    int test1()
    {
        cout 
#include 
using namespace std;

class test4
{
    //private修饰val2，到public结束
private:
    int val2 = 1;
    //public修饰test5，到右大括号结束
public:
    int test5()
    {
        cout

类的作用域

类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员时，需要使用 :: 作用域操作符指明成员属于哪个类域

//class_test.h
#pragma once

class Person
{
    //实现方法
    int test();

    //成员变量
    int age = 0;
    int num = 0;
};

//class_test.cpp（方法定义文件）
#include "class_test.h"

int Person::test()//使用域作用限定符指定是哪个类中的方法
{    
    //之所以能访问到私有变量age和num是因为指定了test函数为Person类中的方法
    //一个类中可以访问到private变量
    return age + num;
}

对象

类的实例化

用类类型创建对象的过程，称为类的实例化

  1. 类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它
//无法直接使用类名创建对象，除非是静态变量
#include 
using namespace std;

class Person
{
public:
    int age;
    static int num;
};

int main()
{
    Person::age = 0;//类在没有对象之前不可以直接使用非静态的成员变量
    Person::num = 0;//静态变量可以直接用类名访问
    return 0;
}
报错信息：
对非静态成员“Person::age”的非法引用

在上面的代码中，因为类中的变量只是声明，告诉编译器当前类有哪些成员变量，但是并不为其开辟空间，而静态变量在编译过程中会分配空间，故可以直接用类名进行访问

需要访问类中的非静态变量时，需要用类名实例化出对象，再用对象去访问类中的变量

#include 
using namespace std;

class Person
{
public:
    int age;
};

int main()
{
    Person p;//实例化
    p.age = 10;
    cout

在上面的代码中，因为p为Person类的对象，故在编译时会为p分配空间，此时p对象的成员变量age就有了存储空间

  1. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量
#include 
using namespace std;

class Person
{
public:
    int age;
};

int main()
{
    //Person类的三个对象
    Person p;
    Person p1;
    Person p2;
    p.age = 10;
    p1.age = 20;
    p2.age = 30;
    cout

类对象的大小

在计算类对象的大小时，和计算结构体大小的方式相同，并且都需要考虑到内存对齐的规则，如果类中有定义成员函数，则不会计算成员函数的大小，只会计算成员变量的大小

class Person
{
    int age;
    int num;

    int test()
    {
        cout

在类对象访问成员变量时，每一个成员变量属于各自的对象存放在栈区，而成员函数是所有对象公共的存放在公共代码段区

如果类中没有成员变量，即只包括成员函数或者是空类时，类的大小为1个字节，这一个字节是为了表示给类占位，标识这个类存在

class Empty
{

};

class NoneMember
{
    void test()
    {
        cout

this关键字

class Person
{
public:
    int age;
    int num;

    void test()
    {
        cout

在上面的代码中，对象p1和对象p2的成员变量age和num有自己的存储的空间，两个对象的成员变量不会冲突，并且尽管test函数是公共的，在test函数中age和num也对应着各自的对象

在C++中，有一个关键字this，是C++编译器给每个“非静态的成员函数“增加的一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成，所以上面的代码实际上是

//对于对象p1
void test(this*)
{
    cout age num

但是上面的代码只是演示，实际过程中不可以显式得将this作为函数的形参

this指针的特点
  1. this指针的类型：类类型* const，即成员函数中，不能给this指针赋值。
  2. 只能在“成员函数”的内部使用
  3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
  4. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递
  5. 一般情况下，this指针存储在栈区上或者寄存器ecx（VS编译器做出的优化）中

注意，this指针有时可以为空，有时不可以为空

  1. 当对象调用函数不需要实际进行解引用操作时，this指针可以为空指针
  2. 当对象调用的函数实际进行解引用操作时，this指针不可以为空指针，否则会出现空指针解引用错误
class test
{
private:
    int val = 0;

public:
    void test1()
    {
        cout test1();//空指针可以直接调用
    (*p).test1();//尽管手动解引用，但是实际上编译器处理时只在需要显式解引用的地方才会进行解引用操作，故此时依旧不会出错
    p->test2();//空指针调用会在获取val处出现空指针解引用问题

    return 0;
}

在上面的代码中，二者均不会出现编译错误，但是对于调用test2来说，因为test2函数中涉及到访问成员变量的空间，而指针对象p是空指针，没有实际的地址空间，导致成员变量val的空间也不存在，从而出现空指针解引用错误，而之所以访问成员函数不需要解引用是因为成员函数并不在对象所在的空间中，不需要在对象的空间中找函数，而是直接去公共代码段中寻找

服务器托管，北京服务器托管，服务器租用 http://www.fwqtg.net

相关推荐: 设计模式-观察者模式

在C++中，观察者模式（Observer Pattern）是一种行为设计模式，用于定义对象之间的一对多依赖关系，当一个对象的状态发生变化时，所有依赖它的对象都将得到通知并自动更新。以下是一个简单的C++观察者模式的示例： 示例一： #include #incl…

服务器托管，北京服务器托管，服务器租用，机房机柜带宽租用

服务器托管

咨询：董先生

电话13051898268 QQ/微信93663045！

上一篇:
下一篇: