C++—类和对象

简介: 本文介绍了类,对象,静态成员,this指针和友元的内容。


🎀 文章作者:二土电子
🐸 期待大家一起学习交流!


一切我们研究的事物,都可以叫做对象。对象具有状态,操作和行为。通常用一个数值来描述对象的状态。对象的操作用于改变对象的状态。对象和对象的操作就是对象的行为。

具有相同或相似性质的对象的抽象就是类。类有属性和操作。通常用数据结构来描述类的属性。类的属性是对对象状态的抽象。用用户名和实现操作的方法来描述类的操作。类的操作是对象行为的抽象。

1 类

C++中定义类的形式为

class 类的名字
{
   
    public:
        公有的数据成员定义
        公有的成员函数
    private:
        私有的数据成员定义
        私有的成员函数
};

类是由类头和类体两部分组成。类头就是class + 类名。类体就是花括号中的内容。类体一般包含两部分

  • 数据成员
    指定类对象的内部表示
  • 成员函数
    指定该类的操作

类的成员有三种不同的访问权限

  • 公有(public)
    成员可以在类外访问
  • 私有(private)
    成员只能被该类内的成员函数访问
  • 保护(protected)
    成员只能被该类的成员函数或派生类的成员函数访问

数据成员通常是私有的。成员函数通常有一部分是公有的,一部分是私有的。公有的成员函数可在类外被访问,也称为类的接口

类的成员函数通常在类外定义。类外定义类的成员函数的一般形式如下

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

在类外定义的成员函数,仍然需要在类内声明。

2 对象

类是用户定义的数据类型,不占内存单元。类存在于静态的程序中(即运行前的程序),而动态的面向对象程序(即运行中的程序)则由对象构成。程序的执行是通过对象之间相互发送消息来实现的,对象是类的实例(占内存单元)。

2.1 创建对象

对象与变量类似。在所有函数之外创建的对象,称为全局对象。在函数内创建的对象,称为局部对象。全局对象和局部对象的生存周期与全局变量和局部变量相同。通过new操作创建的对象,称为动态对象。动态对象需要用delete操作撤销。

以下内容来自C知道
new和delete是动态内存分配和释放的关键字。new可以创建一个指定类型的对象,并返回该对象的指针;delete可以释放一个指定的对象,并将该对象占用的内存返回给系统。这两个关键字经常被用来创建和删除对象。在使用new和delete的时候需要注意内存泄露和指针悬挂的问题。同时,在使用new动态分配内存时,还需要保证分配的内存空间不会超出系统的限制,否则会出现内存申请失败的情况。因此,在使用new和delete时需要谨慎考虑,以确保程序能正确地运行。

int* p = new int(5);
delete p;

2.2 对象的操作

对于创建的一个对象,需要通过调用对象类中定义的成员函数来对它进行操作。操作对象的一般形式为

对象名.成员函数名(实参表)

或者

指向对象的指针->成员函数名(实参表)

这里通过一个简单的例子来展示一下对象的操作

#include<iostream>

using namespace std;

class temp
{
   
    public:
        int a;   // 数据成员

        // 成员函数
        void function1 ()
        {
   
            cout << "function1 is called!" << endl;
        }
        // 类外定义的成员函数的声明
        void function2 ();
};

// 类外成员函数
void temp::function2 ()
{
   
    cout << "function2 is called!" << endl;
}

int main()
{
   
    temp i;   // 创建一个temp类的局部对象
    temp* p;
    p = new temp;   // 创建一个temp类的动态对象,用p指向该对象

    // 调用成员函数对创建的对象进行操作
    i.function1();
    // 调用成员函数对创建的对象进行操作
    p->function2();
    delete p;

    return 0;
}

输出结果为

function1 is called!
function2 is called!

2.3 构造函数

程序运行时创建的每个对象只有在初始化后才能使用。对C++中定义了一种特殊的初始化函数,称之为构造函数。当对象被创建时,构造函数自动被调用。构造函数的名字与类名相同,它没有返回类型和返回值。当对象创建时,会自动调用构造函数进行初始化。当未定义构造函数,但是编译器需要嗲用构造函数时,编译器会自动生成默认的构造函数来初始化对象。因此,并不是所有的类都需要构造函数。这里看一个简单的例子

#include<iostream>

using namespace std;

class temp
{
   
    public:
        int a;   // 数据成员

        // 构造函数
        temp ()
        {
   
            a = 10;
        }
        // 成员函数
        void function1 ()
        {
   
            cout << a << endl;
        }
};

int main()
{
   
    temp i;   // 创建一个temp类的局部对象

    // 调用成员函数对创建的对象进行操作
    i.function1();

    return 0;
}

输出结果为10。如果不定义构造函数,输出结果为0。需要注意的是,对构造函数的调用是对象创建过程的一部分,对象创建之后就不能再调用构造函数了。

2.4 析构函数

当对象销毁时,会自动调用析构函数进行一些清理工作。析构函数也与类同名,但在名字前有一个“~”,析构函数也没有返回类型和返回值。析构函数不带参数,不能重载。析构函数的调用顺序与构造函数的调用顺序相反。下面通过一个简单的例子来理解一下

#include<iostream>

using namespace std;

class temp
{
   

    public:
        // 构造函数
        temp ()
        {
   
            cout << "构造函数被调用" << endl;
        }
        // 析构函数
        ~temp()
        {
   
            cout << "析构函数被调用" << endl;
        }
};

int main()
{
   
    temp i,j;   // 创建temp类的局部对象
    cout << "main函数" << endl;

    return 0;
}

输出结果为

4b661f2fdfd6bf4ebd041810d76ce9e3_287270c1e113477ca239f3fcfc0a21b7.png

3 静态成员

定义静态成员的方法比较简单,直选要在成员变量和成员函数前增加一个“static”即可。静态成员有以下特点

  • 静态成员被类的所有对象共享。不会随着对象的创建而被多次创建和初始化。
  • 静态函数仅能访问静态的数据成员
  • 静态成员变量只能在类外进行初始化
  • 公有的静态成员可以通过“类名::成员函数(输入参数)/成员变量”进行调用和访问
#include<iostream>

using namespace std;

class temp
{
   
    public:
        int a;   // 数据成员

        // 构造函数
        temp ()
        {
   
            a = 10;
        }
};

int main()
{
   
    // 通过对象访问成员变量
    temp i;   // 定义一个temp类的对象

    cout << "a=" << i.a << endl;

    return 0;
}

如果a是静态成员,还可以通过“类名::成员变量名”访问成员变量。

#include<iostream>

using namespace std;

class temp
{
   
    public:
        static int a;   // 数据成员
};

// 静态变量只能在类外进行初始化
int temp::a = 10;

int main()
{
   
    // 通过对象访问成员变量
    temp i;   // 定义一个temp类的对象

    cout << "a=" << i.a << endl;

    // 通过类名访问成员变量
    cout << "a=" << temp::a << endl;

    return 0;
}

4 this指针

在介绍this指针前,先看一个简单的小例子

#include<iostream>

using namespace std;

class temp
{
   
    public:
        void function (int m)
        {
   
            a = m;
            cout << "a=" << a << endl;
        }

    private:
        int a;
        int b;
};

int main()
{
   
    temp i;   // 定义一个类temp的对象

    i.function(1);

    return 0;
}

输出结果为

a=1

现在考虑一个问题,对于类函数function,它是怎么知道是对哪一个对象进行操作呢?这就需要this指针来告诉它。

  • this指针指向当前对象,可以访问当前对象的所有成员变量。包括private、protected、public。
  • this指针是const指针,不可以被赋值和修改。
  • this指针只有在类的非静态成员函数中有定义,仅在类的成员函数中访问。

实际上面的函数可以写成

void function (temp* const this,int m)
{
   
    this -> a = m;
}

5 友元

C++中为了保护数据,使用private访问控制,来限制类外对类内数据成员的访问。C++中可以指定某个全局函数某个其他类或某个其他类的成员函数来直接访问另一个类的私有 (private) 和保护 (protected) 成员,它们分别称为友元函数、友元类和友元类函数,通称为友元。友元的作用是提高程序设计的灵活性,是数据保护和对数据的存取效率之间的一种折中方案。

相关文章
|
1月前
|
编译器 C++
C++之类与对象(完结撒花篇)(上)
C++之类与对象(完结撒花篇)(上)
35 0
|
10天前
|
存储 编译器 C++
【c++】类和对象(中)(构造函数、析构函数、拷贝构造、赋值重载)
本文深入探讨了C++类的默认成员函数,包括构造函数、析构函数、拷贝构造函数和赋值重载。构造函数用于对象的初始化,析构函数用于对象销毁时的资源清理,拷贝构造函数用于对象的拷贝,赋值重载用于已存在对象的赋值。文章详细介绍了每个函数的特点、使用方法及注意事项,并提供了代码示例。这些默认成员函数确保了资源的正确管理和对象状态的维护。
39 4
|
11天前
|
存储 编译器 Linux
【c++】类和对象(上)(类的定义格式、访问限定符、类域、类的实例化、对象的内存大小、this指针)
本文介绍了C++中的类和对象,包括类的概念、定义格式、访问限定符、类域、对象的创建及内存大小、以及this指针。通过示例代码详细解释了类的定义、成员函数和成员变量的作用,以及如何使用访问限定符控制成员的访问权限。此外,还讨论了对象的内存分配规则和this指针的使用场景,帮助读者深入理解面向对象编程的核心概念。
35 4
|
1月前
|
存储 编译器 对象存储
【C++打怪之路Lv5】-- 类和对象(下)
【C++打怪之路Lv5】-- 类和对象(下)
27 4
|
1月前
|
编译器 C语言 C++
【C++打怪之路Lv4】-- 类和对象(中)
【C++打怪之路Lv4】-- 类和对象(中)
23 4
|
1月前
|
存储 安全 C++
【C++打怪之路Lv8】-- string类
【C++打怪之路Lv8】-- string类
21 1
|
1月前
|
存储 编译器 C语言
【C++打怪之路Lv3】-- 类和对象(上)
【C++打怪之路Lv3】-- 类和对象(上)
17 0
|
1月前
|
编译器 C++ 数据库管理
C++之类与对象(完结撒花篇)(下)
C++之类与对象(完结撒花篇)(下)
31 0
|
1月前
|
编译器 C++
C++之类与对象(3)(下)
C++之类与对象(3)(下)
34 0
|
1月前
|
存储 编译器 C++
【C++类和对象(下)】——我与C++的不解之缘(五)
【C++类和对象(下)】——我与C++的不解之缘(五)