一、问题引入

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; //同样正确

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

1. 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

1. 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++类和对象的一些笔记和心得感悟。希望我的分享对你有所帮助。敬请关注，持续更新中~~~