C++类-有了对象之后

本是古典何须时尚 2021-11-10 07:20 105阅读 0赞

原文地址:[https://www.yanbinghu.com/2019/07/28/63773.html][https_www.yanbinghu.com_2019_07_28_63773.html]

## 前言 ##

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

## 乐一乐 ##

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

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

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

## 定义类 ##

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

struct Human
    {
        unsigned int age;
        string name;
        double height;
        /*定义getAge函数，内部用到了age变量*/
        unsigned int getAge()
        {
            return age;
        }
    };

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

struct Human
    {
        /*定义getAge函数，内部用到了age变量*/
        unsigned int getAge()
        {
            return age;
        }
        unsigned int age;
        string name;
        double height;
    };

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

## 声明类 ##

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

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

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

Human human();

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

## 类的作用域 ##

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

unsigned int Human::getAge()
    {
        return age;
    }

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

unsigned int getAge();

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

> 来源：公众号【编程珠玑】  
> 网站：[https://www.yanbinghu.com/2019/07/28/63773.html][https_www.yanbinghu.com_2019_07_28_63773.html]

## 构造函数 ##

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

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

看下面的代码：

//来源：公众号【编程珠玑】
    //网站：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语言入坑指南-被遗忘的初始化][C_-]》。

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

//来源：公众号【编程珠玑】
    //网站：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;
    }

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

Human() = default;

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

## 访问控制与封装 ##

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

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

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

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

因此我们修改class如下：

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函数来访问数据成员，而不是直接访问了：

human.getAge();

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

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

## 类大小 ##

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

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

#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++ 空类大小，你有什么补充的吗？

> 欢迎关注公众号【编程珠玑】，第一时间奉上Linux/C/C++等原创技术文章。

[https_www.yanbinghu.com_2019_07_28_63773.html]: https://www.yanbinghu.com/2019/07/28/63773.html
[C_-]: https://www.yanbinghu.com/2018/11/13/9002.html
[Link 1]: https://www.yanbinghu.com/2018/09/15/43741.html