C++语法知识点合集：3.类和对象（2）

最新推荐文章于 2024-09-04 17:18:01 发布
最新推荐文章于 2024-09-04 17:18:01 发布
阅读量707 收藏 27
点赞数 27
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_79453595/article/details/141615616
版权

文章目录

一、类的6个默认函数

空类中，编译器会自动生成以下6个成员函数

初始化：构造函数
清理：析构函数
拷贝构造：使用同类对象初始化创建对象
赋值重载：把一个对象赋值给另一个对象
普通对象取地址
const对象取地址

二、构造函数

1.概念

构造函数名字与类名相同，创建类 类型对象时由编译器自动调用，保证了每个数据成员都有一个合适的初始值，并且在对象整个生命周期内只调用一次。

2.使用

构造函数并不是开空间对象，而是初始化对象

代码如下（示例）：

#include <stdio.h>
#include <iostream>
using namespace std;
class date
{
public:
    // 无参构造函数
    date()
    {
        cout << "date" << endl;
    }
    // 带参构造函数
    date(int year, int month)
    {
        _year = year;
        _month = month;
        cout << _year << "-" << _month << endl;
    }

private:
    int _year;
    int _month;
};
int main()
{
    // 调用无参构造函数
    date d1;
    date d2(2000, 1);
    return 0;
}
  • 构造函数的函数名与类名相同，无返回值，可以重载
  • 对象实例化时编译器自动调用对应的构造函数

若类中没有显式定义构造函数，C++编译器会自动生成一个无参的默认构造函数，(不传实参就可以调用的构造就叫默认构造),一旦显式定义编译器将不再生成。

  • C++招类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的原生数据类型如:int/char/double/指针等，自定义类型就是我们使用class/struct等关键字自己定义的类型。内置类型成员变量在类中声明时可以给默认值。

编译器默认生成的构造，对内置类型成员变量的初始化没有要求。对于自定义类型成员变量，要求调用这个成员变量的默认构造函数初始化。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要用初始化列表才能解决

三、析构函数

1.概念

与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由
编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

2.使用

  1. 析构函数名是在类名前加上字符 ~,无参数无返回值类型。
  2. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数
  3. 析构函数不能重载,对象生命周期结束时，C++编译系统系统自动调用析构函数。
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
typedef int dataType;
class Stack
{
public:
    Stack(size_t capacity = 10)
    {
        _array = (dataType *)malloc(sizeof(dataType) * capacity);
        if (_array == nullptr)
        {
            perror("malloc申请空间失败");
            return;
        }
        _capacity = capacity;
        _size = 0;
    }
    ~Stack()
    {
        if (_array)
        {
            free(_array);
            _array = nullptr;
            _size = 0;
            _capacity = 0;
        }
    }
    void Push(dataType data)
    {
        _array[_size] = data;
        _size++;
    }

private:
    int _capacity;
    int _size;
    dataType *_array;
};
class Time
{
public:
    ~Time()
    {
        cout << "~Time" << endl;
    }

private:
    int _hour;
    int _min;
    int _second;
};
class Date
{
private:
    int _year = 2000;
    int _month = 01;
    int _day = 01;
    Time _t;
};
void testStack()
{
    Stack s;
    s.Push(1);
    s.Push(2);
}
void testTime()
{
    Date date;
}
int main()
{
    testStack();
    // main函数中不能直接调用Time类的析构函数，实际要释放的是Date类对象
    // 编译器会调用Date类的析构函数，而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，
    // 当Date对象销毁时，保证其内部每个自定义对象都可以正确销毁
    testTime();
    return 0;
}

在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <assert.h>
using namespace std;
typedef int dataType;
class Stack
{
public:
    Stack()
    {
        _array = nullptr;
        _capacity = 0;
        _size = 0;
    }
    ~Stack()
    {
        free(_array);
        _array = nullptr;
        _capacity = 0;
        _size = 0;
    }
    void push(int x)
    {
        if (_size == _capacity)
        {
            int newSize = _capacity == 0 ? 4 : _capacity * 2;
            dataType *temp = (dataType *)realloc(_array, sizeof(dataType) * newSize);
            if (temp == nullptr)
            {
                perror("fail realloc");
                return;
            }
            _capacity = newSize;
            _array = temp;
        }
        _array[_size] = x;
        _size++;
    }
    int pop()
    {
        assert(_size > 0);
        int res = _array[_size - 1];
        _size--;
        return res;
    }
    int peek()
    {
        assert(_size > 0);
        return _array[(_size - 1)];
    }
    bool empty()
    {
        return _size == 0;
    }

private:
    dataType *_array;
    int _capacity;
    int _size;
};
class MyQueue
{
public:
    void push(int x)
    {
        pushStack.push(x);
    }
    int peek()
    {
        if (popStack.empty())
        {
            while (!pushStack.empty())
            {
                dataType top = pushStack.peek();
                popStack.push(top);
                pushStack.pop();
            }
        }
        return popStack.peek();
    }

    int pop()
    {
        dataType res = peek();
        popStack.pop();
        return res;
    }

    bool empty()
    {
        return pushStack.empty() && popStack.empty();
    }

private:
    Stack pushStack;
    Stack popStack;
};

四、拷贝构造函数

1.概念

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存
在的类类型对象创建新对象时由编译器自动调用。

2.使用

#include <stdio.h>
// 拷贝构造函数是构造函数的一个重载形式。
// 因为会引发无穷递归调用
// 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错
class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    Date(const Date &d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }

private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    Date d1;
    Date d2(d1);
    return 0;
}
  • 若未显式定义，编译器会生成默认的拷贝构造函数。

默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成。

#include <iostream>
using namespace std;
class Time
{
public:
    Time()
    {
        _hour = 1;
        _minute = 1;
        _second = 1;
    }
    Time(const Time &t)
    {
        _hour = t._hour;
        _minute = t._minute;
        _second = t._second;
        cout << "Time::Time(const Time&)" << endl;
    }

private:
    int _hour;
    int _minute;
    int _second;
};
class Date
{
private:
    // 基本类型(内置类型)
    int _year = 1970;
    int _month = 1;
    int _day = 1;
    // 自定义类型
    Time _t;
};
int main()
{
    Date d1;
    // 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
    // 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数
    Date d2(d1);
    return 0;
}
  • 类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

错误典型

#include <stdio.h>
#include <stdlib.h>
// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
typedef int DataType;
class Stack
{
public:
    Stack(size_t capacity = 10)
    {
        _array = (DataType *)malloc(capacity * sizeof(DataType));
        if (nullptr == _array)
        {
            perror("malloc申请空间失败");
            return;
        }
        _size = 0;
        _capacity = capacity;
    }
    void Push(const DataType &data)
    {
        // CheckCapacity();
        _array[_size] = data;
        _size++;
    }
    ~Stack()
    {
        if (_array)
        {
            free(_array);
            _array = nullptr;
            _capacity = 0;
            _size = 0;
        }
    }

private:
    DataType *_array;
    size_t _size;
    size_t _capacity;
};
int main()
{
    Stack s1;
    s1.Push(1);
    s1.Push(2);
    s1.Push(3);
    s1.Push(4);
    Stack s2(s1);
    // 当程序退出时，s2和s1要销毁。s2先销毁，s2销毁时调用析构函数，
    // 已经将_array的空间释放了，但是s1并不知道，到s1销毁时，会将_array的空间再释放一次，
    // 一块内存空间多次释放，造成程序崩溃。
    return 0;
}

正确写法:深拷贝

#include <stdio.h>
#include <stdlib.h>

typedef int DataType;

class Stack {
public:
    Stack(size_t capacity = 10) {
        _array = (DataType *)malloc(capacity * sizeof(DataType));
        if (nullptr == _array) {
            perror("malloc申请空间失败");
            return;
        }
        _size = 0;
        _capacity = capacity;
    }

    // 深拷贝拷贝构造函数
    Stack(const Stack &s) {
        _array = (DataType *)malloc(s._capacity * sizeof(DataType));
        if (_array == nullptr) {
            perror("malloc申请空间失败");
            return;
        }
        _size = s._size;
        _capacity = s._capacity;
        for (size_t i = 0; i < _size; i++) {
            _array[i] = s._array[i];
        }
    }

    void Push(const DataType &data) {
        // CheckCapacity();
        _array[_size] = data;
        _size++;
    }

    ~Stack() {
        if (_array) {
            free(_array);
            _array = nullptr;
            _capacity = 0;
            _size = 0;
        }
    }

private:
    DataType *_array;
    size_t _size;
    size_t _capacity;
};

int main() {
    Stack s1;
    s1.Push(1);
    s1.Push(2);
    s1.Push(3);
    s1.Push(4);
    Stack s2(s1); // 深拷贝，不会导致内存问题
    return 0;
}

3. 拷贝构造函数典型调用场景

  • 使用已存在对象创建新对象
  • 函数参数类型为类类型对象
  • 函数返回值类型为类类型对象

五、赋值运算符重载

1.运算符重载

  • C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
  • 函数名字为：关键字operator后面接需要重载的运算符符号。
  • 函数原型：返回值类型 operator操作符(参数列表)
  1. 不能通过连接其他符号来创建新的操作符：比如operator@
  2. 重载操作符必须有一个类类型参数
  3. 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义
  4. 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为this
  5. 注意以上5个运算符不能重载。
// 全局的operator==
#include <iostream>
using namespace std;
class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    // private:
    int _year;
    int _month;
    int _day;
};
bool operator==(const Date &d1, const Date &d2)
{
    return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
}
void Test()
{
    Date d1(2018, 9, 26);
    Date d2(2018, 9, 27);
    cout << (d1 == d2) << endl;
}


// bool operator==(Date* this, const Date& d2)
    bool operator==(const Date &d2)
    {
        return _year == d2._year && _month == d2._month && _day == d2._day;
    }

2.赋值运算符重载

  • 参数类型：const T&，传递引用可以提高传参效率
  • 返回值类型：T&，提高返回的效率，有返回值为了支持连续赋值
  • 检测是否自己给自己赋值
  • 返回*this ：要复合连续赋值的含义
Date &operator=(const Date &d)
    {
        if (this != &d)
        {
            _year = d._year;
            _month = d._month;
            _day = d._day;
        }
        return *this;
    }

赋值运算符只能重载成类的成员函数，不能重载成全局函数

class Date
{
public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 int _year;
 int _month;
 int _day;
};
// 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
Date& operator=(Date& left, const Date& right)
{
 if (&left != &right)
 {
 left._year = right._year;
 left._month = right._month;
 left._day = right._day;
 }
 return left;
}

编译错误，赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了

用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。
内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。

3 前置++和后置++重载

  • 前置++：返回+1之后的结果。
  • this指向的对象函数结束后不会销毁，故以引用方式返回提高效率
  • 前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载
  • 后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this+1
class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    Date &operator++()
    {
        _day += 1;
        return *this;
    }
    Date operator++(int)
    {
        Date temp(*this);
        _day += 1;
        return temp;
    }

private:
    int _year;
    int _month;
    int _day;
};

六、const成员函数

将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数
隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

#include <iostream>
using namespace std;
class Date
{
public:
    Date(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    void Print()
    {
        cout << "Print()" << endl;
        cout << "year:" << _year << endl;
        cout << "month:" << _month << endl;
        cout << "day:" << _day << endl;
    }
    void Print() const
    {
        cout << "Print()const" << endl;
        cout << "year:" << _year << endl;
        cout << "month:" << _month << endl;
        cout << "day:" << _day << endl;
    }

private:
    int _year;
    int _month;
    int _day;
};
void Test()
{
    Date d1(2022, 1, 13);
    d1.Print();
    const Date d2(2022, 1, 13);
    d2.Print();
}

七、取地址及const取地址操作符重载

这两个默认成员函数一般不用重新定义 ，编译器默认会生成

ruiruiupup
关注
  • 27
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++学习:对象和类详细总结
谢小小XH
07-12 1万+
C++对象和类总结
作业练习1：C++基础语法与知识点.md
09-30
作业练习1：C++基础语法与知识点.md
C++期末复习超详细总结知识点（期末冲刺）
Augenstern_QXL的博客
06-04 9万+
✍、C++期末复习总结知识点(期末突击与冲刺)
C++~类和对象总结（万字大总结，值得收藏）
Zebra的博客
10-21 3231
我们不写，编译器默认生成的构造函数我们写的无参构造函数我们写的全缺省构造函数（全缺省最常用，因为使用的时候既可以传参数也可以不传参数）C++把类型分成内置类型(基本类型包括指针)和自定义类型。默认生成构造函数对于内置类型成员变量不做处理，对于自定义类型成员变量才会处理（会调用这个自定义类型成员的默认构造函数）
C/C++常见面试知识点总结附面试真题----20220326更新
热门推荐
生命在于折腾！
09-19 14万+
以下内容部分整理自网络，部分为自己面试的真题。 第一部分：计算机基础 1. C/C++内存有哪几种类型？ C中，内存分为5个区：堆(malloc)、栈(如局部变量、函数参数)、程序代码区（存放二进制代码）、全局/静态存储区（全局变量、static变量）和常量存储区（常量）。此外，C++中有自由存储区（new）一说。 2. 堆和栈的区别？ 1).堆存放动态分配的对象——即那些在程序运行时分配的对象......
面向对象程序设计与c++知识点整理
Yosh1n0的博客
12-13 1927
bjtu面向对象程序设计与c++知识点汇总
【全网首发】言简意赅的Python全套语法，内附详细知识点和思维导图！【强烈建议收藏！】
迷茫与徘徊只会让你陷入绝境，欢迎私信博主，带你开始提升变现价值！
04-16 5万+
Python是近几年比较火热的编程语言，至于有多火热？偶尔打开微信公众号，页面下面弹出的是《Python训练营》，打开朋友圈发现有推荐学习Python的课程，打开CSDN，发现热榜第一又是Python推荐文章，不得不说Python的影响力在目前还是比较大的，这和Python社区的宣传力度有着密切的关系！ 目前学习Python的人有多少呢？那些人在学习Python呢？至于这个问题，我认为没有一个准确的答案，因为每一天学习Python的人都在增加，学习Python被越来越多的人注重，所以要回答这个问题，最好的
C++入门知识点总结——基本语法
wangyongyao1989的博客
06-21 2169
C++ 是一种静态类型的、编译式的、通用的、大小写敏感的、不规则的编程语言，支持过程化编程、面向对象编程和泛型编程。 1.面向对象程序设计: C++ 完全支持面向对象，包括面向对象开发的四大特性： 封装 抽象 继承 多态 C++标准库的组成： 核心语言，提供了所有构件块，包括变量、数据类型和常量等； C++ 标准库，提供了大量的函数，用于操作文件、字符串等； 标准模板库（STL），提供了大量的方法，用于操作数据结构等。 C++ 程序可以定义为对象的集合，这些对象通过调用彼此的方法进行交互：
C++类和对象相关内容详细总结（值得收藏喔~）
xbhinsterest11的博客
03-21 3386
快来快来 伴随着风景一起的 C++万字详细总结！！！
C++类和对象（万字总结）（建议收藏！！！）
IamGreeHand的博客
09-27 9352
文章目录面向过程和面向对象初步认识类的引入类的定义类的两种定义方法1.声明和定义全部放在类体中2. 声明放在.h文件中，类的定义放在.cpp文件中类的访问限定符及封装访问限定符封装类的作用域类的实例化类对象模型如何计算类对象的大小类对象的存储方式this 指针this指针的引出this指针的特性类的6个默认成员函数构造函数构造函数的特性析构函数特性拷贝构造函数特性运算符重载==运算符重载= 运算符重载const修饰成员函数再谈构造函数构造函数体赋值初始化列表注意事项1.每个成员变量在初始化列表中只能出现一次
【C++】类和对象
QiHai的博客
08-07 3934
大家好呀，嘿嘿，现在我们即将面对C++的一大拦路虎--类和对象。这将是我们学习C++语法的一大难点，突破此我们才算真正打开C++的学习大门！话不多说，和我一起攻略吧！ᕦ(･ㅂ･)ᕤ
C++软件开发工程师面试资料（C++语法知识点、数据库知识点、计算机网络知识点）.zip
11-06
于2019.7-2019.10备战秋招，准备的C++软件开发岗的面试资料，资料涵盖了：1、C++中的基本语法、STL、C++11新特性的面试知识点；2、计算机网络的面试知识点；3、MYSQL数据库的面试知识点；4、计算机网络的面试知识点...
C++程序设计与实践：07-第6章 深入类和对象.ppt
06-12
本资源摘要信息涵盖了深入类和对象的知识点，包括深复制和浅复制、禁止复制、对象的三种创建方法、对象的初始化方法、this指针、指向类对象的指针、指向类成员的指针、友元关系等，为学习C++程序设计与实践的学生...
C++语法大全公开课获奖课件.pptx
11-13
本篇总结了C++语法的基本概念和知识点，涵盖了数据类型、常量和变量、运算符和表示式、语句等方面的内容。 数据类型 C++中数据类型可以分为三类：内置基本数据类型、复合类型和类类型。内置基本数据类型包括字符...
少儿编程C++初级基础知识点.zip
10-23
这个压缩包包含了多个章节的源代码文件，涵盖了C++语言的基础概念和关键语法，让我们逐一解析这些知识点。 1. **第一章：C++简介** 这一章通常会介绍C++的历史、特点以及它在软件开发中的应用。学习者会了解到C++...
C语言：刷题笔记
weixin_45930573的博客
09-04 252
c语言刷题记录
【C++】STL—vector的使用
最新发布
2301_77112794的博客
09-04 503
本文介绍了vector重点函数接口的使用
【C++】深入理解C++模板：从基础到进阶
2403_86785171的博客
09-01 642
模板是C++中用于泛型编程的工具。它允许你编写可以处理任意类型的函数和类，而不必重复编写相似的代码。函数模板和类模板。
【C++】智能指针——auto_ptr，unique_ptr，shared_ptr
2301_79796701的博客
09-01 1251
1.智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时 ++或--，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2.这样引用计数就错 乱了。旧的智能指针的会转移给新的智能指针，而旧的智能指针的会被置空。解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了，weak_ptr不会增加引用计数，代码示意。该问题是有类似于链表节点的结构引起的，当外部的智能指针都释放了，就拿不内部的智能指针，那么节点就不会释放。使用方法参考官方文档。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值