C++之旅-类初识

发表于 | 更新于: | 分类于 | 阅读次数:

前言

无论是在Java还是Python中，都有类的概念，类的基本思想是数据抽象和封装，一个类定义了一种数据类型以及相关的操作。C++中类是怎样的呢？本文将结合C语言，来介绍C++中的类。

乐一乐

问：C++的书为什么比C厚那么多？
答：有了对象后就是麻烦。

虽然这只是调侃，但不得不承认，C++在语法特性上要比C复杂，因此本文也只是挑选类的部分内容来阐述。

另外一提，面向对象本身是一种编程思想，只是C++在语言特性层面就支持面向对象，而C并不支持。

定义类

与C语言中定义结构体类似，只不过C++的类中，除了有数据，还有相关操作，例如：

1
2
3
4
5
6
7
8
9
10
11
struct Human
{
    unsigned int age;
    string name;
    double height;
    /*定义getAge函数，内部用到了age变量*/
    unsigned int getAge()
    {
        return age;
    }
};

从上面可以看到，除了多了getAge成员函数，其他部分和C语言中的结构体是没有太大的差别的。但是需要注意的是，编译器在处理类的时候，先编译成员的声明，然后才会轮到成员函数。也就是说，即便getAge函数在age的声明之前，也是可以编译过的。

1
2
3
4
5
6
7
8
9
10
11
struct Human
{
    /*定义getAge函数，内部用到了age变量*/
    unsigned int getAge()
    {
        return age;
    }
    unsigned int age;
    string name;
    double height;
};

上面的代码中，虽然age的声明再getAge函数之后，但是不影响编译。

声明类

以下几种方式都可以用来声明类：

1
2
Human human;
struct Human human1;//这种形式和C语言中非常像

不过下面这种方式是不行的奥：

1
Human human();

因为这会被认为是函数的声明，因此编译会报错。从后面可以看到，

类的作用域

类本身就是一个作用域，所以我们可以看到，在getAge函数中，可以直接访问age成员。而成员函数也可以定义在类的外部，但是为了说明这个成员函数是类的成员，就必须使用作用域符，例如在类的外部定义getAge:

1
2
3
4
unsigned int Human::getAge()
{
    return age;
}

当然前提是在类中已有声明：

1
unsigned int getAge();

通常来说，成员函数实现可能比较复杂，因此常常会在类中声明成员函数，但是在类的外部定义，以便阅读和组织代码。

来源：公众号【编程珠玑】
网站：https://www.yanbinghu.com

构造函数

无论在C语言中还是在C++中，对于临时变量（或者说非静态，全局变量）声明之后最好进行初始化。对于普通数据类型，如int，double等都可以直接初始化为0，那么类中的数据是复杂的，我们必须有一个或几个函数用来实现类对象的初始化，类中这样的一个或几个函数就是构造函数。对于构造函数需要关注以下几点：

  • 构造函数没有返回值
  • 构造函数名与类名相同
  • 构造函数可以重载
  • 构造函数不能被声明成const
  • 如果没有定义任何构造函数，编译器会为我们提供没有参数的默认构造函数

看下面的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//来源：公众号【编程珠玑】
//网站：https://www.yanbinghu.com
#include <iostream>
using namespace std;
struct Human
{
    unsigned int age;
    string name;
    double height;
    unsigned int getAge()
    {
        return age;
    }
};
int main()
{
    Human human;//这里会去调用默认构造函数
    cout<<"age:"<<human.age<<endl;
    return 0;
}

在main函数中，我们声明了一个Human对象，虽然我们有默认的构造函数，但是由于默认构造函数并没有对成员进行初始化，因此每次运行的结果还是不一样。至于原因可以参考《C语言入坑指南-被遗忘的初始化》。

因此我们需要定义自己的构造函数，用来控制对象的初始化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//来源：公众号【编程珠玑】
//网站：https://www.yanbinghu.com
#include <iostream>
using namespace std;
struct Human
{
    unsigned int age;
    string name;
    double height;
    /*构造函数*/
    Human(int a,string n,double h)
    {
        age = a;
        name = n;
        height = h;
    }
    unsigned int getAge()
    {
        return age;
    }
};
int main()
{
    //Human human;//这一行会报错，因为定义了构造函数之后，不会合成默认没有参数的构造函数
    Human human(10,"shouwang",180);
    cout<<"age:"<<human.age<<endl;
    cout<<"name:"<<human.name<<endl;
    cout<<"height:"<<human.height<<endl;
    return 0;
}

这里也验证了我们前面说到的一点，如果定义了自己的构造函数，那么就不会合成默认构造函数，如果还想要默认的构造函数呢？很简单，只需要在类中增加一行：

1
Human() = default;

在这种情况下，构造函数就不止一个，即构造函数被重载了。

访问控制与封装

前面也说到，类的基本思想是数据抽象和封装，那么必然有一些东西用来控制访问权限的。它们就是访问说明符：

  • public说明符：在其之后的成员在整个程序内可以被访问，通常用于定义类的接口
  • private说明符：在其之后的成员不能被使用该类的外码使用，但是可以被类的成员函数访问，通常用于类的数据成员
  • protected说明符：与private成员类似，但是其基类可访问

另外也可以使用class代替struct，只是他们的默认访问权限不一样，class定义的类的成员默认是private的，而struct的成员默认是public的。因此我们可以看到在前面的main函数中，可以直接使用.运算符访问数据成员，但是如果换成class就不太一样了，这个时候就会报错，因为在这种情况下，构造函数也是不可访问的：

1
error: ‘Human::Human(int, std::string, double)’ is private within this context

因此我们修改class如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Human
{
/*数据成员声明为private*/
private:
    unsigned int age;
    string name;
    double height;
/*类接口声明为public*/
public:
   /*默认构造函数*/
    Human() = default;
    /*构造函数*/
    Human(int a,string n,double h)
    {
        age = a;
        name = n;
        height = h;
    }
    unsigned int getAge()
    {
        return age;
    }
};

这个时候，就需要通过调用getAge函数来访问数据成员，而不是直接访问了：

1
human.getAge();

封装有什么好处呢？显然：

  • 确保封装对象不会被无意间破坏数据
  • 封装细节不对外呈现，其实现可以随意改变，但是不影响外部使用

类大小

虽然类中有很多成员，包括数据成员和成员函数，但是对于一个类占用的空间来说，与C中的struct是类似的，即使用sizeof计算其大小时，只需要计算其非静态数据成员大小（严格来说，是非静态数据成员，虚函数，虚基类），所以对于64位程序来说，sizeof(Human)的大小为24字节（需要考虑字节对齐，可参考《理一理字节对齐的那些事》）。到这里其实也可以猜想，不同的Human对象数据成员不同，但是其普通成员函数都是只有一份。

但是需要特别注意的是，C++类允许没有数据成员，那么一个没有数据成员的类（没有非静态数据成员变量，没有虚函数，也没有虚基类），大小是多少呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
using namespace std;
class Empty
{
    void test()
    {
        /*do something*/
    }
};
int main()
{
    Empty e;
    cout <<  sizeof(e) << endl;
}

运行结果为：1，而不是0。
为什么呢？C++标准里规定，为了避免不同的对象具有相同的地址，对象大小不允许为0。

总结

我们从前面的内容可以看到，与C语言相比，C++的类至少多了以下特点：

  • 成员函数定义在类中，即操作和数据都在类中，而不像C语言中数据与操作分离
  • 使用特定的函数，即构造函数进行初始化
  • 使用访问说明符来封装，决定哪些可以被用户访问，哪些不能

而本文需要特别注意的点如下：

  • class与struct本质没有太大区别，只是默认访问控制权限不一样
  • 构造函数没有返回值
  • 编译器在处理类的时候，先编译成员的声明，然后才会轮到成员函数

介绍到这里你以为就完了吗?还早的很。

如有不妥之处，还请多多指教。

讨论

关于C++ 空类大小，你有什么补充的吗？

守望 wechat
关注公众号[编程珠玑]获取更多原创技术文章
出入相友，守望相助！