C++知识点的回顾

最新推荐文章于 2024-08-12 16:55:46 发布
最新推荐文章于 2024-08-12 16:55:46 发布
阅读量175 收藏
点赞数
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cffid/article/details/128635638
版权

一.  面向对象基础

    1.类与对象的概念

           类：类是对同一类对象的抽象总结，是一个概念。 一个类最主要包括属性和行为

          对象：按照类的规定创建的实体。

    2.实例化对象

          类是一个抽象的概念，所以需要我们按照概念来创建对应的对象。在C++中有两种类型的对象：分别是栈内存对象，堆内存对象。

  •  栈内存对象

                在生命周期结束（所在的花括号执行完）后，自动被销毁。

                栈内存对象使用 . 调用成员。

  • 堆内存对象

            需要使用new关键字创建，使用delete关键字销毁，如果不销毁，则会持续存在，容易导致 内存泄漏的问题，内存泄漏最终可能会导致程序卡顿，甚至卡死。

           堆内存对象通常使用指针来保存堆内存对象的地址。

          堆内存对象使用 -> 调用成员，在Qt Creator下，直接打.会转换成 ->

4.封装

         封装就是根据业务的需求将类的一些属性和细节隐藏起来，并重新公开给外部一些开放的调用接口。当然它的封装写法也不唯一，在实际的过程中结合业务需求而定。通常先对属性私有化，使属性隐藏，然后根据当前属性的需求，通过getter函数和setter函数对类外分别公开读和写的功能。如下代码：

#include <iostream>
using namespace std;
class MobilePhone
{
private: // 私有权限：只有类内部可访问
    string brand; // 可读可写
    string model; // 只写
    int weight = 188; // 初始值

public: // 公开接口
    string get_brand() // getter：读属性
    {
        return brand;
    }

    void set_brand(string b) // setter：写属性
    {
        brand = b;
    }

    void set_model(string m) // setter
    {
        model = m;
    }

    int get_weight() // getter
    {
        return weight;
    }

};

int main()
{
     
    MobilePhone mp1;
    mp1.set_brand("小米");
    mp1.set_model("13 Pro");
    cout << mp1.get_brand() << " " << mp1.get_weight() << endl;
    
    MobilePhone* mp2 = new MobilePhone;
    mp2->set_brand("红米");
    mp2->set_model("K60 Pro");
    cout << mp2->get_brand() << " " << mp2->get_weight() << endl;

    delete mp2;
    return 0;
}

二 .  构造函数

    1. 概念

        构造函数类内一种特殊的函数，用来创建一个对象。如果一个类中，程序员不手动编写构造函数，编译器会为这个类自动添加一个无参构造函数，且此函数的函数体为空；如果程序员手写了任意一个构造函数，编译器就不再自动添加构造函数了。构造函数要求函数名必须与类名完全一致，且构造函数无需写返回值。

  •  2.用法
  •    可以给构造函数增加参数，使用参数给属性赋予初始值，使对象的创建更灵活。
  •    构造函数也支持函数重载，遵守之前函数重载的规则。
  •    构造函数也支持之前的参数默认值设定。

   三 .  构造初始化列表

  1. 构造初始化列表是一种简便的写法，可以用于给属性赋予初始值。

#include <iostream>

using namespace std;

class MobilePhone
{
private:
    string brand;
    string model;
    int weight;
public:
    MobilePhone(string b = "8848",
                string m="钛金手机",
                int w = 199):brand(b),model(m),weight(w)
    {}
   void show() // 展示所有属性值
   {
       cout << brand << " " << model << " "
            << weight << endl;
   }
};
int main()
{
    MobilePhone mp1("小米","13Pro",190);
    mp1.show();

    return 0;
}

四 . 析构函数

       1.析构函数是与构造函数对立的函数

构造函数

析构函数

手动调用

在对象被销毁时自动调用

通常用于在对象创建时初始化

通常用于在对象销毁时回收资源

可以被重载

不可以重载，因为没有参数

函数名是类名

函数名是~类名

五 .作用域限定符 ::

1.内类声明，内外定义

         对于类中的成员也可以声明定义分离，如果声明定义分离，通常在类内声明，在类外定义，类外的定义需要结合作用域限定符使用。

#include <iostream>

using namespace std;

class Test
{
private:
    string str = "随便";

public:
    // 类内声明
    Test(); // 无参构造
    string get_str(); // getter
};

// 类外定义
string Test::get_str()
{
    return str; // 也属于类内
}

Test::Test()
{
    cout << "构造函数" << endl;
}

int main()
{
    Test t;
    cout << t.get_str() << endl;

    return 0;
}

六.this指针

   1. 概念

           this指针是一个特殊的指针，保存的是当前类的对象首地址。

           this所在的函数是哪个对象的，this指向的就是这个对象。

2.原理

        在类内调用此类的成员，虽然不用手写this指针，但是编译器都会使用this指针来调用成员，因为成员只能由对象来调用，而this指针指向的就是当前类的对象。

#include <iostream>

using namespace std;

class Student
{
private:
    string name;

public:
    Student(string s)
    {
        this->name = s;
    }

    string get_name()
    {
        return this->name;
    }

    void show()
    {
        cout << this->get_name() << endl;
    }
};

int main()
{
    Student s("张三");
    s.show(); // 张三

    return 0;
}

3.利用this指针的原理，其应用有：

  • 区分重名的成员变量与局部变量--------当成员变量与局部变量重名时，可以使用this指针调用成员变量。
  • 链式调用------如果一个函数的返回值是当前类的引用，那么通常此函数需要返回一个*this，并且此函数支持链式调用。
  • 多态传参

七. static关键字

1.static关键字在类内有以下几种用法：

  • 静态局部变量------使用static关键字修饰局部变量就是静态局部变量。
  • 静态成员变量-----------成员变量使用static修饰就是静态成员变量,静态成员变量有以下特点：                       1. 此类的所有对象共用此变

                          2.非const的静态成员变量通常需要类内声明，类外初始化

                         3.  静态成员变量可以直接使用类名::来调用，更推荐使用此方式

                         4.静态成员变量在程序运行时创建，在程序结束时销毁

  • 静态成员函数--------------成员函数使用static修饰就是静态成员函数，静态成员函数的特点有：

                        1.静态成员函数不能访问此类中非静态成员，因为没有this指针

                        2.静态成员函数只能调用本类中静态的成员

                        3.非静态成员函数可以调用静态成员

                        4.除了可以使用当前类对象调用静态成员函数外，也可以直接使用类名::调用，

                       5.如果静态成员函数声明与定义分离，只需要在声明处使用static修饰

八.const关键字

       1.   在C++中，虽然认为const表示常量的意思，但是严格地讲，const并不是常量。因为C++中const只能在程序的运行期间只读，即在编译期可以改变数值。

     常成员函数:const修饰的成员函数，表示常成员函数，这种函数的特点是：

              1.可以调用本类中非const的成员变量，但是不能修改其数值

               2.不能调用非const的成员函数

               建议成员函数只要不修改成员变量值就写为常成员函数，例如getter

    常量对象:const修饰对象，表示该对象为常量对象，其特点有：

                 1.常量对象的任何属性值不能被修改

                 2.常量对象不能调用任何非const的成员函数

                const修饰对象时，const关键字可以写在类名前面，也可以类名后面。

  常成员变量:使用const修饰成员变量，表示该成员变量为常成员变量，其特点有：

                  1.程序运行时，常成员变量的值不可变

                  2.不能在函数体中赋值，只能通过直接赋值或构造初始化列表赋值

 修饰局部变量:类似于之前给引用参数增加const修饰，函数的局部变量都可以使用const修饰，表示常量。

九.运算符重载

         1.  友元：友元是一种定义在类外部的普通函数，但他需要在类内进行说明，为了和该类的成员函数加以区别，在说明时前面加以关键字friend。

友元主要分为以下几种使用情况：

  • 友元函数
  • 友元类
  • 友元成员函数

友元函数：友元函数是一种类外的函数，但是需要在类内结合friend关键字进行说明（非声明），需要注意以下几点：

  • 因为友元函数不是类内的函数，因此没有this指针，因此需要给友元函数增加一个传递对象的参数位，用此对象来调用类中的成员。
  • 友元函数不属于类，因此不受类中权限修饰符的影响，即友元函数的说明可以放在类中的任意位置。
  • 一个友元函数可以访问多个类的成员，只需要在多个类中分别说明。
#include <iostream>

using namespace std;

class Test
{
private:
    int a = 1;
    // 友元函数的说明，放在类中的任意位置都可以
    friend void test_friend(Test& t);
};

// 友元函数在类外
void test_friend(Test& t)
{
    t.a++;
    cout << t.a << endl;
}

// 不是友元函数
void test(Test& t)
{
//    t.a++; 错误
//    cout << t.a << endl; 错误
}

int main()
{
    Test t;
    test_friend(t); // 2
    return 0;
}

友元类：当一个类B成为了另一个类A的“朋友”时，类A的所有成员就可以被类B访问，此时类B是类A的友元类。需要注意的是：

  • 友元关系是单向的，不具有交换性。
  • 友元关系不具有传递性。
  • 友元关系不能被继承。

友元成员函数：可以使类B中的某一个成员函数成为类A的友元成员函数，这样类B中只有这个成员函数可以访问类A的所有成员。

#include <iostream>

using namespace std;

// 第三步
class A;

// 第二步
class B
{
public:
    void func(A& a); // 先只声明
};

// 第一步
class A
{
private:
    int i = 1;

    // 说明友元成员函数
    friend void B::func(A& a);
};

// 第四步，补齐友元函数的定义
void B::func(A &a)
{
    a.i++;
    cout << a.i << endl;
}

int main()
{
    A a;
    B b;
    b.func(a); // 2

    return 0;
}

运算符重载：

       1. 概念：函数可以重载，运算符也是一种特殊的函数，因此运算符也可以重载。

可以被重载的运算符：

        算术运算符：+、-、*、/、%、++、--

        位操作运算符：&、|、~、^(位异或)、<<(左移)、>>(右移)

        逻辑运算符：!、&&、||

        比较运算符：<、>、>=、<=、==、!=

        赋值运算符：=、+=、-=、*=、/=、%=、&=、|=、^=、<<=、>>=

       其他运算符：[]、()、->、,、new、delete、new[]、delete[]

不被重载的运算符：

        成员运算符 .、指针运算符 *、三目运算符 ? :、sizeof、作用域 ::

友元函数运算符重载：

                            可以使用友元函数进行运算符重载。        

截取部分代码： 
class Integer
{
private:
    int value;

public:
    Integer(int value):value(value){}

    int get_value() const
    {
        return value;
    }

    // 友元函数的说明
    friend Integer operator +(const Integer& i1,
                              const Integer& i2); // 双目
    friend Integer operator ++(Integer& i); // 单目,前置
    friend Integer operator ++(Integer& i,int); // 单目,后置
};

Integer operator +(const Integer& i1,
                   const Integer& i2)
{
    return i1.value+i2.value;
}
Integer operator ++(Integer& i)
{
    return ++i.value;
}
Integer operator ++(Integer& i,int)
{
    return i.value++;
}

成员函数运算符重载：

          也可以使用成员函数进行运算符重载，成员函数的运算符函数对应的输入参数比同样使用友元函数实现的友元函数的参数少一个。

class Integer
{
private:
    int value;

public:
    Integer(int value):value(value){}

    int get_value() const
    {
        return value;
    }

    // 成员函数运算符重载
    Integer operator +(const Integer& i);
    Integer operator ++(); // 前置
    Integer operator ++(int); // 后置
};

Integer Integer::operator +(const Integer& i)
{
    // this表示运算数1
    return this->value+i.value;
}

Integer Integer::operator ++()
{
    return ++this->value;
}

Integer Integer::operator ++(int)
{
    return this->value++;
}

赋值运算符重载：

            赋值运算符重载函数只支持成员函数运算符重载，不支持友元函数运算符重载的方式。

   相关部分代码

// 编译器自动添加赋值运算符重载函数
    Teacher& operator =(const Teacher& right)
    {
        this->subject = right.subject;
        cout << "赋值运算符：" << subject << endl;
        return *this;
    }
通常无需手动编写赋值运算符重载，以下情况需要手动编写，编译器不在自动添加赋值运算符重载函数：
  • 当前类的成员变量出现指针
  • 屏蔽赋值运算符的使用（权限为private）
类型转换运算符重载： 可以使自定义类型的对象自动转换为任意类型，此函数也只能使用成员函数运算符重载
相关部分代码： 

    operator string() // 格式比较特殊
    {
        return subject;
    }

十.字符串类 std::string

               std::string是一种特殊容器的类型，用于操作字符序列。

empty ---空

swap-----交换

append---向后追加字符串

push_back-----向后追加一个字符

insert-------插入

replace----替换

erase----删除

不爱吃香菜的小曹
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++相关知识的总结和回顾
02-17
阅读完C++ Primer Plus（第6版）后自己总结的一些知识点，其中的内容我也发布在我的博客空间中，因为使用linux vim进行编写，并且原始编写格式是.cpp，因此相比于我发布的文章这个文件中的格式更加清晰，舒适。
C++学习
xiaoming_Super的博客
04-25 764
C++程序可以定义为对象的集合，对象通过调用彼此的方法进行交互。
第二章 - 数据类型与运算
weixin_55577641的博客
06-25 1165
在程序执行期间其值可以改变的量称为变量。一个变量应该有一个名字，并在内存中占据一定的存储单元，在改存储单元中存放变量的值。变量其实只不过是程序可操作的存储区的名称。C++ 中每个变量都有指定的类型，类型决定了变量存储的大小和布局，该范围内的值都可以存储在内存中，运算符可应用于变量上。在C++语言中，要求对所有用到的变量做强制定义，也就是必须“先定义，后使用”，变量定义就是告诉编译器在何处创建变量的存储，以及如何创建变量的存储。在这里，type。
【C/C++】：C++总体回顾
weixin_52988524的博客
09-25 952
本篇文章主要用于C++一些专有名词的解释以及对C语言扩充功能的说明，如果想详细了解C++的用法以及代码的讲解建议参考其他专业书籍。
C++回顾--基础
ivalue的博客
09-08 260
1：声明：让编译器“认识”这个标识符        定义：给变量分配内存 2：变量的存储类型 auto：采用堆栈方式分配内存空间，属于暂时性存储，其存储空间可以被若干变量多次覆盖 register：存放在通用寄存器中 extern：在所有函数和程序段中都可以引用 static：在内存中是以固定地址存放，在整个程序运行过程中都有效 应该和变量的作用域和可见性结合理解 3：枚举   ...
C++回顾
weixin_51312090的博客
07-17 146
文章目录前言一、C++的三大特性1.封装2.继承3.多态二、C++与C1.不同2.相同总结 前言 学了一个学期的C++，进行回顾。 一、C++的三大特性 1.封装 在C++中，通过类将数据与对数据的操作进行封装。封装的数据及操作有：public，private，protected三种。对数据成员通常使用private或protected以防止数据成员在不经意间被修改，而需要被子类继承的数据成员需为protected类型。 2.继承 被继承的是基类，继承出来的类是派生类，子类拥有父类的所有的特性。继承能够.
C++面试题基础知识回顾
02-08
1、C 和 C++ 中 struct 有什么区别？ Protection行为 能否定义函数 C 无 否，但可以有函数指针 C++ 有 可以，默认是public 2、C++中的 struct 和 class 有什么区别？ 【参考答案】从语法上讲，class和struct做...
软件工程知识回顾.ppt
11-12
下面我们将深入探讨几个核心知识点。 首先，我们来看一个简单的C++程序示例。这个程序用于计算两个整数的商和余数。程序使用了iostream库进行输入输出操作，通过`#include <iostream.h>`引入。`void main()`是程序...
c++语言知识点总结 英文版 适合查询和快速回顾知识点
02-02
c++语言知识点总结 英文版 适合查询和快速回顾知识点，比大多中文版总结得要好
第三章C面向对象程序设计知识点回顾优秀文档.ppt
11-30
本章主要回顾了C++中面向对象的一些关键知识点。 1. **类与对象**： 类是C++中定义数据结构和操作数据结构的方法的蓝图。它不是数据对象，而是一种类型定义。每个类的实例称为对象，每个对象都是类中定义的数据...
c++回顾（一）
丁胜利的博客
02-09 320
2018/2/9 The first day of the winter holiday in my hometown.Review c++ and record attention points. 1.enum #include &lt;iostream&gt; using namespace std; enum time { first,second, third,...
C++笔记5•内存管理•
最新发布
qq_64446190的博客
08-12 684
内存管理
c++ error: ‘*’ does not name a type； did you mean ‘**’?
xiaozhi
08-08 478
c++ error: ‘*’ does not name a type； did you mean ‘**’?
STL中的迭代器失效（vector为例）
2302_80190394的博客
08-08 366
STL中的迭代器失效（vector为例）
【C++】智能指针
dab112的博客
08-07 925
谈论了内存泄漏，以及可以使用智能指针来解决该类问题
C语言一维数组(含数组二分查找)
hdxbufcbjuhg的博客
08-09 1187
在⼀个升序的数组中查找指定的数字n，很容易想到的⽅法就是遍历数组，但是这种⽅法效率⽐较低。比如我们之前写的猜数字游戏，会生成一个随机数来让玩家猜，范围是1~100，那玩家会从1开始一个一个猜吗，不会吧，那样就太慢了，我们一般会从整体的一半开始猜，比如猜50，告诉你大了还是小了，这样只需要一步就可以排除庞大数字中的一半，比如假设猜1 ~ 10000，猜5000后就可以知道猜大了还是小了，直接排除了5000个数字，效率很快，这就是⼆分查找，也叫折半查找。
理解栈（Stack）及其在 C++ 中的应用【栈、数据结构】
qq_22841387的博客
08-07 434
栈是一种数据结构，它遵循“后进先出”（LIFO - Last In, First Out）的原则。栈就像是一叠盘子，你只能从最上面拿盘子，也只能在最上面放盘子。栈的这一特性使其在很多场景中非常有用，例如递归、回溯算法和表达式计算等。通过这篇博客，我们详细介绍了栈的基本概念及其在 C++ 中的实现。栈是一种非常有用的数据结构，尤其在处理递归、回溯和表达式计算等问题时。我们还讨论了如何将栈中的字符转换为字符串，以及如何使用栈解决括号匹配问题。
C++ 知识点（长期更新）
weixin_51332735的博客
08-09 2002
必知必会
C语言家教记录（三）
C_eeking的博客
08-08 539
本次授课讲述第五章和第六章内容，关键点：选择和循环
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值