C++类的定义和对象的创建

一、问题引入

C++类和对象到底是什么意思？

1、C++ 中的类（Class）可以看做C语言中结构体（Struct）的升级版。结构体是一种构造类型，可以包含若干成员变量，每个成员变量的类型可以不同；

2、可以通过结构体来定义结构体变量，每个变量拥有相同的性质。

例如：

#include <stdio.h>

//定义结构体 Student
struct Student{
    //结构体包含的成员变量
    char *name;
    int age;
    float score;
};
//显示结构体的成员变量
void display(struct Student stu)
{
    printf("%s的年龄是 %d，成绩是 %f\n", stu.name, stu.age, stu.score);
}

int main()
{
    struct Student stu1;
    //为结构体的成员变量赋值
    stu1.name = "小明";
    stu1.age = 15;
    stu1.score = 92.5;
    //调用函数
    display(stu1);

    return 0;
}

运行结果：
小明的年龄是 15，成绩是 92.500000

而c++中类虽然也是一种构造类型，但是较结构体更为灵活高级，同时局限性较小。

类的成员可以是变量，还可以是函数；通过类定义出来的变量也有特定的称呼，叫做“对象”。

例如：

#include <stdio.h>

//通过class关键字类定义类
class Student
{
public:
    //类包含的变量
    char *name;
    int age;
    float score;
    //类包含的函数（这里即体现出类的成员可以是变量，也可以是函数）
    void say()
    {
        printf("%s的年龄是 %d，成绩是 %f\n", name, age, score);
    }
};

int main()
{
    //通过类来定义变量，即创建对象
    class Student stu1;  //也可以省略关键字class
    //为类的成员变量赋值
    stu1.name = "小明";
    stu1.age = 15;
    stu1.score = 92.5f;
    //调用类的成员函数
    stu1.say();

    return 0;
}

运行结果：
小明的年龄是 15，成绩是 92.500000

二、c++类定义

定义一个类需要使用关键字 class，然后指定类的名称，并类的主体是包含在一对花括号中，主体包含类的成员变量和成员函数。

定义一个类，本质上是定义一个数据类型的蓝图，它定义了类的对象包括了什么，以及可以在这个对象上执行哪些操作。

例如：

class Book
{
public:
double length; // 书的长度
double breadth; // 书的宽度
double height; // 书的高度
};

关键字 public 确定了类成员的访问属性。在类对象作用域内，公共成员在类的外部是可访问的。

补充：

class是 C++ 中新增的关键字，Book专门用来定义类。是类的名称；类名的首字母一般大写，以和其他的标识符区分开。{ }内部是类所包含的成员变量和成员函数，它们统称为类的成员（Member）；由{ }包围起来的部分有时也称为类体，和函数体的概念类似，public也是 C++ 的新增关键字，它只能用在类的定义中，表示类的成员变量或成员函数具有“公开”的访问权限。

注意在类定义的最后有一个分号;，它是类定义的一部分，表示类定义结束了，不能省略。

类只是一个模板（Template），编译后不占用内存空间，所以在定义类时不能对成员变量进行初始化，因为没有地方存储数据。只有在创建对象以后才会给成员变量分配内存，这个时候就可以赋值了。

三、C++对象定义

类提供了对象的蓝图，所以基本上，对象是根据类来创建的。声明类的对象，就像声明基本类型的变量一样。下面的语句声明了类 Book 的两个对象：

Book Book1; // 声明 Box1，类型为 Box
Book Book2; // 声明 Box2，类型为 Box

对象 Book1 和 Book2 都有它们各自的数据成员。

Book是类名，Book1和Book2是对象名，这和使用基本类型定义变量的形式类似：

int a; //定义整型变量

从这个角度考虑，我们可以把 Book 看做一种新的数据类型，把 Book1、Book2看做一个变量。

在创建对象时，class 关键字可要可不要，但是出于习惯我们通常会省略掉 class 关键字。

例如：

class Book Book1; //正确

Book Book1; //同样正确

除了创建单个对象，还可以创建对象数组：

Book Book1[100];

该语句创建了一个Book1数组，它拥有100个元素，每个元素都是 Book 类型的对象。

四、访问类的成员

和通过结构体变量来访问它的成员类似：

#include <iostream>
using namespace std;

//类通常定义在函数外面
class Student{
public:
    //类包含的变量
    char *name;
    int age;
    float score;
    //类包含的函数
    void say(){
        cout<<name<<"的年龄是"<<age<<"，成绩是"<<score<<endl;
    }
};

int main(){
    //创建对象
    Student stu;
    stu.name = "小明";
    stu.age = 15;
    stu.score = 92.5f;
    stu.say();

    return 0;
}

运行结果：
小明的年龄是15，成绩是92.5

stu 是一个对象，占用内存空间，可以对它的成员变量赋值，也可以读取它的成员变量。

类通常定义在函数外面，当然也可以定义在函数内部，不过很少这样使用。

为了更好理解，下面我引用一段实例来进行说明：

#include <iostream>

using namespace std;

class Box
{
public:
double length; // 长度
double breadth; // 宽度
double height; // 高度
// 成员函数声明
double get(void);
void set( double len, double bre, double hei );
};
// 成员函数定义
double Box::get(void)
{
return length * breadth * height;
}

void Box::set( double len, double bre, double hei)
{
length = len;
breadth = bre;
height = hei;
}
int main( )
{
Box Box1; // 声明 Box1，类型为 Box
Box Box2; // 声明 Box2，类型为 Box
Box Box3; // 声明 Box3，类型为 Box
double volume = 0.0; // 用于存储体积

// box 1 详述
Box1.height = 5.0;
Box1.length = 6.0;
Box1.breadth = 7.0;

// box 2 详述
Box2.height = 10.0;
Box2.length = 12.0;
Box2.breadth = 13.0;

// box 1 的体积
volume = Box1.height * Box1.length * Box1.breadth;
cout << "Box1 的体积：" << volume <<endl;

// box 2 的体积
volume = Box2.height * Box2.length * Box2.breadth;
cout << "Box2 的体积：" << volume <<endl;

// box 3 详述
Box3.set(16.0, 8.0, 12.0);
volume = Box3.get();
cout << "Box3 的体积：" << volume <<endl;
return 0;
}

运行结果

Box1 的体积：210
Box2 的体积：1560
Box3 的体积：1536

Box1、Box2、Box3 是一个对象，占用内存空间，可以对它的成员变量赋值，也可以读取它的成员变量。

类通常定义在函数外面，当然也可以定义在函数内部，不过很少这样使用。

五、对象指针

Book bok;
Book *pBok = &bok;

代码中创建的对象 stu 在栈上分配内存，需要使用&获取它的地址。pStu 是一个指针，它指向 Book 类型的数据，也就是通过 Book 创建出来的对象。

同时，也可以在栈上创建对象，这时需要用到关键字new

Book *pBok = new Book;

在栈上创建出来的对象都有一个名字，比如 bok，使用指针指向它不是必须的。但是通过 new 创建出来的对象就不一样了，它在堆上分配内存，没有名字，只能得到一个指向它的指针，所以必须使用一个指针变量来接收这个指针，否则以后再也无法找到这个对象了，更没有办法使用它。也就是说，使用 new 在堆上创建出来的对象是匿名的，没法直接使用，必须要用一个指针指向它，再借助指针来访问它的成员变量或成员函数。（ 非常重要！！！）

栈内存是程序自动管理的，不能使用 delete 删除在栈上创建的对象；堆内存由程序员管理，对象使用完毕后可以通过 delete 删除。在实际开发中，new 和 delete 往往成对出现，以保证及时删除不再使用的对象，防止无用内存堆积。

有了对象指针后，可以通过箭头->来访问对象的成员变量和成员函数，这和通过结构体指针来访问它的成员类似，请看下面的示例：

pBok -> length = 20;
pBok -> height = 15;
pBok -> breadth = 92.5f;
pBok -> void set(X,X,X);

以上就是关于我学习C++类和对象的一些笔记和心得感悟。希望我的分享对你有所帮助。敬请关注，持续更新中~~~文章来源地址https://uudwc.com/A/OnRL2