C++ 类和对象_默认成员函数

最新推荐文章于 2023-08-10 22:56:23 发布

rugu-sco

最新推荐文章于 2023-08-10 22:56:23 发布

阅读量145

点赞数

分类专栏： C++ 文章标签：类和对象默认成员函数

本文链接：https://blog.csdn.net/sinat_36629696/article/details/81134366

版权

C++ 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

类和对象

1. 什么是面向对象？

面向对象程序设计

概念：(Object Oriented Programming，缩写：OOP）是一种程序设计范型，同时也是一种程序开发的方法。

对象指的是类的实例，将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性。

通俗的理解就是 , 把一种事物起一个名字(类名) , 然后把它有的各种属性(成员变量)写出来 ,

再把它能干的事情(成员函数)写出来 , 通过类名定义一个它的对象 , 然后这个对象就有这些属性 , 就可以干这些事情了 , 通过不同对象的组合 , 从而解决我们的问题

类 (class / struct)
{
    成员函数

    成员变量
} ;

2. 类的大小？为什么要内存对齐？内存对齐的计算？空类的计算

C语言中计算结构体的大小需要内存对齐 , 类也一样

对齐规则为 :

第一个成员在结构体变量偏移量为0的地址处
其他成员变量要对齐到对齐数的整数倍的地址处

对齐数 = min(编译器默认的一个对齐数 , 该成员的大小)

VS中默认的值为 8

gcc中的默认值为 4

结构体总大小为最大对齐数（每个成员变量除了第一个成员都有一个对齐数）的整数倍
如果嵌套了结构体，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的总大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍

例如 :

// gcc 对齐数 默认是 4
class A
{
public:
    char ch ; // 1 字节
    double d ; // 8 字节 对齐数是 4
}; // 1000 1111 1111 总大小为 12
class B
{
    char ch1 ; // 1 字节
    A a ; // 12 字节  最大对齐数是 4
    char ch2 ; // 1 字节
}; // 1000 1111 1111 1111 1000 总大小是 20
class C
{
    void print()
    {
        _a = 100;
        cout << _a << endl;
    }
private:
    int _a;
};
class D
{

};
void Test04()
{
    cout << sizeof(A) << endl; // 12
    cout << sizeof(B) << endl; // 20
    cout << sizeof(C) << endl; // 4
    cout << sizeof(D) << endl; // 1
}

那么 , 为什么要存在内存对齐呢 ? 这样不是浪费了很多空间吗 ?

有两个原因

平台原因(移植原因)：

不是所有的硬件平台都能访问任意地址上的任意数据的；

某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
性能原因：

数据结构(尤其是栈)应该尽可能地在自然边界上对齐。

原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；

而对齐的内存访问仅需要一次访问。

我们以为内存是这样的

这里写图片描述
其实它是这样的

这里写图片描述
CPU 把内存当成一块一块的 , 块的大小可以是2，4，8，16字节大小，因此CPU在读取内存时是一块一块进行读取的。

块大小称为 memory access granularity（粒度） 翻译为 “内存读取粒度”

例如 :

这里写图片描述
现在要读取一个 int 类型的变量 , 4 字节大小 , 如果这个变量存在 0 开始处 , 那么一次读 4 个 , 只用一次就可以读完 , 同样如果它在 4 开始 , 也是一次读完

但是 , 如果没有内存对齐 , 它在 1 开始处 , CPU 只能先读取 0 ~ 3 , 再读取 4 ~ 7 , 然后把 0 和 5 ~ 7 删除 , 得到 1 ~ 4 , 这样才能读出这个变量

显然这样效率就要差很多 , 所以内存对齐可以提高 CPU 读取内存的速度 , 提高效率

3. 类的4个默认成员函数的详细使用及细节

一个类 ,有 6 个默认的成员函数

构造函数
拷贝构造函数
析构函数
赋值操作符的重载
取地址操作符的重载
const 修饰的取地址操作符的重载

其中最重要的是前 4 个

1. 构造函数

因为成员变量是私有的 , 无法在类外直接访问 , 所以需要一个默认的成员函数来对其进行初始化 , 并且这个默认的成员函数需要在对象被定义的时候自动执行一次 , 这个函数就叫做

构造函数 , 它有一些特点

没有返回值
函数名和类名相同
对象实例化时, 系统自动调用对应的构造函数
可以在类外定义 , 也可以在类中定义
如果类中没有写构造函数 , 编译器会生成一个默认的构造函数 , 只要我们定义了一个构造函数 , 系统就不会再生成默认构造函数
无参的构造函数和全缺省的构造函数都认为是默认构造函数 , 并且默认构造函数只能有一个
构造函数可以重载

无参的构造函数和有参的构造函数

class Date
{
    public :
        // 1.无参构造函数
        Date ()
        {
            cout << "Date()" << endl;
        }
        // 2.带参构造函数
        Date (int year, int month , int day )
        {
            cout << "Date(...)" << endl;
            _year = year ;
            _month = month ;
            _day = day ;
        }
    private :
        int _year ;
        int _month ;
        int _day ;
};
void TestDate1 ()
{
    Date d1 ; // 调用无参构造函数
    Date d2 (2015, 1, 1); // 调用带参的构造函数
    // Date d3 (); // 这种写法是错误的 , 这里没有调用 d3 的构造函数定义出 d3
}

带缺省参数的构造函数

class Date
{
    public :
        // 3.全缺省参数的构造函数
            /*Date (int year = 2000, int month = 1, int day = 1)
            {
                cout << "Date(.. .. ..)" << endl;
                _year = year ;
                _month = month ;
                _day = day ;
            }*/
        // 4.半缺省参数的构造函数（不常用）
        Date (int year, int month = 1)
        {
            cout << "Date(  .. )" << endl;
            _year = year ;
            _month = month ;
            _day = 1;
        }
    private :
        int _year ;
        int _month ;
        int _day ;
};
void Test()
{
    Date d1(2010) ; // 调用半缺省构造函数
    //Date d2 (2015, 2); // 调用半缺省构造函数
}

注意 : 1. 缺省参数只能从右往左定义 2. 如果构造函数的定义和声明分离 , 既可以在声明中给缺省参数 , 也可以在定义中给

2. 拷贝构造函数

创建对象时用同类的另一个对象来初始化 , 这是调用的构造函数称为拷贝构造函数 , 拷贝构造函数其实就是构造函数的重载 , 有如下特点 :

必须使用引用传参 , 如果用传值可能引发无穷递归

因为传值会发生形参到实参的拷贝 , 这个时候又会调用拷贝构造函数 , 调用拷贝构造函数又要发生形参到实参的拷贝 , 又要调拷贝构造函数 ..… 于是就会无穷递归

事实上 , 除了传引用不是传值外 , 其他传参方式都是传值的 , 指针也是 , 只不过指针传递的是对象的地址的值 , 所以拷贝构造只能传引用 !

实际中 , 写成传值的方式也是编译不过的

如果没有定义拷贝构造函数 , 系统会自动生成默认的拷贝构造函数 , 它会依次拷贝类的成员进行初始化

class Date
{
public :
    Date()
    {}
    // 拷贝构造函数
    Date (const Date &d)
    {
        _year = d ._year;
        _month = d ._month;
        _day = d ._day;
    }
private :
    int _year ;
    int _month ;
    int _day ;
};
void TestDate1 ()
{
    Date d1 ;
    // 下面两种用法都是调用拷贝构造函数，是等价的。
    Date d2 (d1); // 调用拷贝构造函数
    Date d3 = d1; // 调用拷贝构造函数
}

3. 析构函数

在一个对象的生命周期结束时 , 系统会自动调用一个成员函数来做一些清理工作 , 这个成员函数叫析构函数 , 有如下特点 :

写法 : ~ 类名( ) 例如 ~Date()
没有参数 , 没有返回值
在对象的声明周期结束时自动被系统调用
如果自己没有定义析构函数 , 系统会生成默认的析构函数
一个类中 , 析构函数只能有一个
析构函数体内并不是删除这个对象 , 而是做一些清理工作

#include <malloc.h>
class Array
{
    public :
        Array (int size)
        {
            cout << "申请空间" << endl;
            _ptr = (int *)malloc( size * sizeof (int) );

        }
        // 这里的析构函数需要完成的清理工作就是释放空间
        ~ Array ()
        {
            cout << "释放空间" << endl;
            if (_ptr )
            {
                free(_ptr );
                _ptr = 0;
            }
        }
    private :
        int *_ptr ;
};

void Test05()
{
    Array arr(5);
}

4. 赋值操作符的重载

为了增强程序的可读性 , C++ 支持运算符的重载

运算符重载以后不能改变运算符的优先级 , 结合性 , 操作数

用法 : 返回类型 operator 运算符 () 例如 : void operator+ ()

有 5 个运算符不能被重载 :

? : : 条件运算符

:: : 作用域限定符

. : 成员访问运算符

.* : 成员指针访问运算符

sizeof : 长度运算符

class Date
{
public :
    Date()
    {}
    // 拷贝构造函数
    Date (const Date &d)
        : _year(d._year)
        , _month(d._month)
        , _day(d._day)
    {
        cout << "拷贝构造" << endl;
    }
    // 赋值操作符的重载
    // 1.为什么 operator= 赋值函数需要一个 Date& 的返回值
    //   答 : 这样可以不用调用拷贝构造函数 , 提高效率
    //        并且, 默认生成的拷贝构造函数是浅拷贝, 使用传值返回的话, 
    //        如果类中有申请释放空间之类的操作, 就会出现问题, 
    //        比如一块空间被释放了两次
    Date& operator= (const Date &d)
    {
        cout << "赋值操作符的重载" << endl;
        // 2.这里的if条件判断是在检查什么？
        //   答 : 防止自己给自己赋值
        if (this != &d)
        {
            this->_year = d. _year;
            this->_month = d. _month;
            this->_day = d. _day;
        }
        return *this ;
    }
private:
    int _year ;
    int _month ;
    int _day ;
};

void Test06 ()
{
    Date d1 ;
    Date d2 = d1; // 调用拷贝构造函数
    Date d3 ;
    d3 = d1 ; // 调用赋值运算符的重载
}

当类的对象需要拷贝时，拷贝构造函数将会被调用。

以下情况都会调用拷贝构造函数 :

一个对象以值传递的方式传入函数体
一个对象以值传递的方式从函数返回
一个对象需要通过另外一个对象进行初始化

在类中没有定义拷贝构造函数时 , 系统会默认生成拷贝构造函数 , 这个拷贝构造函数完成对象之间的浅拷贝

class TestCls{
    public:
        int a;
        int *p;

    public:
        TestCls(int _a = 0)   //无参构造函数
            :a(_a)
        {
            std::cout<<"TestCls()"<<std::endl;
            // p = new int;
        }

        ~TestCls()     //析构函数
        {
            // delete p;   
            std::cout<<"~TestCls()"<<std::endl;
        }
        void Set_a(int _a)
        {
            a = _a;
        }
        void print()
        {
            cout << a << endl;
            cout << &a << endl;
            cout << p << endl;
        }
    private:
        // 这样这个类就不可以被拷贝了
        TestCls(const TestCls& ts)
        {}
};
void Test07()
{
    TestCls tc1(100);
    TestCls tc2 = tc1;
    tc1.print();
    tc2.print();
    tc2.Set_a(200);
    tc1.print();
    tc2.print();
}

成员变量的初始化有两种方式 :

构造函数体内进行赋值
初始化列表

其中初始化列表更加高效

用法 :

Date(int t_year, int t_month, int t_day)
    :m_year(t_year), m_month(t_month), m_day(t_day)
    {}

为什么初始化列表更加高效 ?

因为即使不用初始化列表 , 这一步也会执行一次 , 所以用了初始化列表就免去了函数体内进行赋值的操作 , 从而效率更高

有一些成员变量必须用初始化列表进行初始化

const 成员变量
引用类型的成员变量
没有默认构造函数的类成员变量

注意 : 成员变量的初始化是按声明的顺序进行初始化的 , 而非初始化列表的顺序

class Time
{
    public :
        Time (const Time &t)
        {
            cout << "Time (const Time& t)" << endl;
            _hour = t._hour;
            _minute = t._minute;
            _second = t._second;
        }
    private:
        int _hour ;
        int _minute ;
        int _second ;
};
class Date
{
    public :
        Date (int year, int month , int day, const Time &t)
            :_testConst(100), _testReference(_year), _t(t)
        {
            cout << "Date ()" << endl;
            _year = year ;
            _month = month ;
            _day = day ;
            _t = t ;
        }
    private :
        int _year ; // 年
        int _month ; // 月
        int _day ; // 日
        const int _testConst; // 1.测试 const 成员变量的初始化
        int &_testReference ; // 2.测试引用成员变量的初始化
        Time _t ; // 3.测试无缺省构造函数的成员变量的初始化
};

void Test08()
{
    Time tm;
    Date dt(2018, 7, 20, tm);
}

rugu-sco

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C++ 类和对象_默认成员函数

类和对象1. 什么是面向对象？面向对象程序设计概念：(Object Oriented Programming，缩写：OOP）是一种程序设计范型，同时也是一种程序开发的方法。对象指的是类的实例，将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性。通俗的理解就是 , 把一种事物起一个名字(类名) , 然后把它有的各种属性(成员变量)写出来 ...
复制链接

扫一扫