C++ 语言学习 day10 复习（1）

最新推荐文章于 2024-11-05 15:26:40 发布
最新推荐文章于 2024-11-05 15:26:40 发布
阅读量382 收藏
点赞数
分类专栏： # C++  语言的学习 文章标签： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/she666666/article/details/127988702
版权

1.
/********* 探讨权限 ************
 * 权限|位置    类外  类内  派生
 * 公有：       √     √    √
 * 保护：       ×     √    √
 * 私有：       ×     √    ×

 * 总结:
 *      类外：只能访问公有成员
 *      类内：可访问所有成员
 *      派生：无法访问祖先类的私有成员
 *
 * 注意:
 *      C++中权限关键字开始位置就是权限
 *      直到下一个权限关键字或者类结束
 * ****************************/

******************************************************
 * 什么时候使用相关权限?
 * 公有:一般想让外界直接访问的之后使用公有权限,类似接口函数
 * 保护:既不想要外部访问,但是又想让派生类继承使用则使用保护权限
 * 私有:只允许内部自己访问,派生无法访问
 * ******************************************************/
 

2.


/********* 构造函数 和 析构函数 ***************
 *构造函数:
 *  作用:用于申请空间时初始化处理
 *  定义:
 *      1.函数名与类名相同
 *      2.无返回值
 *      --->通过从上定义规则可以发现,构造函数可以拥有参数,则可实现重载
 *析构函数:
 *  作用:用于销毁时做释放处理
 *  定义:
 *      1.函数名与类名相同,但多了一个~号
 *      2.无参，无返回值
 *      --->然通过以上定义规则发现,析构函数无法重载
 * 注意:
 *  如果用户没有提供构造和析构以及拷贝等函数则编译器默认提供
 *  1.无参构造
 *  2.拷贝构造(浅)
 *  3.析构函数
 *  4.=运算符函数
 * ******************************************/

代码：

#include <iostream>
#include <string>
using namespace std;

/********* 构造函数 和 析构函数 ***************
 *构造函数:
 *  作用:用于申请空间时初始化处理
 *  定义:
 *      1.函数名与类名相同
 *      2.无返回值
 *      --->通过从上定义规则可以发现,构造函数可以拥有参数,则可实现重载
 *析构函数:
 *  作用:用于销毁时做释放处理
 *  定义:
 *      1.函数名与类名相同,但多了一个~号
 *      2.无参，无返回值
 *      --->然通过以上定义规则发现,析构函数无法重载
 * 注意:
 *  如果用户没有提供构造和析构以及拷贝等函数则编译器默认提供
 *  1.无参构造
 *  2.拷贝构造(浅)
 *  3.析构函数
 *  4.=运算符函数
 * ******************************************/

class People
{
public:
    People();   /*无参构造*/
    People(string name,int age,string sex = "女");   /*带参构造*/
    People(const People &people);                    /*拷贝构造*/

    ~People();  /*析构函数*/
public:
    void Print() const;/*接口函数*/
    void operator =(const People &people) /*=号赋值运算符*/
    {
        this->m_name = people.m_name;
        this->m_age = people.m_age;
        this->m_sex = people.m_sex;
        cout << "=号赋值运算符" << endl;
    }
protected:
    string m_name;  /*姓名*/
    int m_age;      /*年龄*/
    string m_sex;   /*性别*/
};
/***** 类外实现 *****/
People::People()    /*无参构造*/
{
    this->m_name = "";
    this->m_age = 0;
    this->m_sex = "女";
    cout << "无参构造" << endl;
}

People::People(string name,int age,string sex)/*带参构造*/
{
    this->m_name = name;
    this->m_age = age;
    this->m_sex = sex;
    cout << "带参构造" << endl;
}

People::People(const People &people) /*拷贝构造*/
{
    this->m_name = people.m_name;
    this->m_age = people.m_age;
    this->m_sex = people.m_sex;
    cout << "拷贝构造" << endl;
}

People::~People()  /*析构函数*/
{
    cout << "析构函数" << endl;
}

void People::Print() const
{
    cout << "\t姓名:" << this->m_name
         << "\t年龄:" << this->m_age
         << "\t性别:" << this->m_sex
         << endl;
}

int main()
{
    /*1.实例化对象*/
    People people1;                   /* 默认调用无参 */

    People people2("张三",18,"男");    /*带参构造*/
    People people3("李四",17);        /*带参构造*/

    People people4(people2);    /*拷贝构造*/

    People people5 = people2;   /*拷贝构造*/
    people5 = people3;          /*=号赋值运算符*/
    /********* 输出结果内容 **********/
    cout << "\npeople1:" << endl;
    people1.Print();

    cout << "\npeople2:" << endl;
    people2.Print();

    cout << "\npeople3:" << endl;
    people3.Print();

    cout << "\npeople4:" << endl;
    people4.Print();

    cout << "\npeople5:" << endl;
    people5.Print();
    return 0;
}

3.
/*********** 浅拷贝 Vs 深拷贝 *************************
 *浅拷贝: 是值拷贝,针对指针变量,则都是指向到同一片内存空间地址
 *      会造成:①一个操作多个对象 ②多次析构照成程序崩溃
 *深拷贝: 在堆区申请空间的操作都要实现
 *      注意：一般牵扯指针操作,都会自己实现深拷贝
 ****************************************************/

代码：

#include <iostream>
#include <string>
using namespace std;

/*********** 浅拷贝 Vs 深拷贝 *************************
 *浅拷贝: 是值拷贝,针对指针变量,则都是指向到同一片内存空间地址
 *      会造成:①一个操作多个对象 ②多次析构照成程序崩溃
 *深拷贝: 在堆区申请空间的操作都要实现
 *      注意：一般牵扯指针操作,都会自己实现深拷贝
 ****************************************************/
class A{
public:
    A(){cout << "A的构造函数" <<endl;}
    ~A(){cout << "A的析构函数" <<endl;}
    string name[1000];
};

class People
{
public:
    People()
    {
        a = new A;  /*申请*/
    }
    /******** 深拷贝 ********/
    People(const People &people)
    {
        /*** 重新申请空间,并修改指向 ***/
        this->a = new A;  /*申请空间,修改指向*/
        *this->a = *people.a;/*拷贝内容到新的空间*/
        cout << "深拷贝构造函数" << endl;
    }

    ~People()
    {
        delete a;   /*释放*/
    }
public:
    A *a;    /* 类成员指针 */
};


int main()
{
    /***** 打印大小 *****/
    cout << "sizeof(string) = " << sizeof(string) << endl;
    cout << "sizeof(A) = " << sizeof(A) << endl;
    cout << "sizeof(People) = " << sizeof(People) << endl;
    /***** 1.实例化对象 ****/
    People *people = new People;

    people->a->name[0] = "张三";


    People people1(*people); /* 拷贝构造 */
    people1.a->name[0] = "李四";

    cout << "people->a->name[0]" << people->a->name[0] << endl;
    cout << "people1.a->name[0]" << people1.a->name[0] << endl;

    delete people;
    return 0;
}

4.

/****** 程序的执行顺序(初始化顺序) **************
 * 1.自上而下
 * 2.从左往右
 * 总结:初始化列表不会影响正常初始化顺序
 * 总结:析构顺序与初始化顺序相反
 * *****************************************/

代码：

other.h

#ifndef OTHER_H
#define OTHER_H
#include <iostream>
using namespace std;

class A{
public:
    A(){cout << __func__<< endl;}
    A(int xx){cout << __func__<< endl;}
    ~A(){cout << __func__<< endl;}
};

class B{
public:
    B(){cout << __func__<< endl;}
    B(int xx){cout << __func__<< endl;}
    ~B(){cout << __func__<< endl;}
};

class C{
public:
    C(){cout << __func__<< endl;}
    ~C(){cout << __func__<< endl;}
};

class D{
public:
    D(){cout << __func__<< endl;}
    ~D(){cout << __func__<< endl;}
};

/**** 人类中包含A和B *****/
class People : public C,public D{
public:
    People()
    :b(20),a(10)/*初始化列表 父类构造 -> 成员*/
    {cout << __func__<< endl;}
    ~People(){cout << __func__<< endl;}
public:
    A a;
    B b;
};

class Student
{
public:
    Student(string name,int age)
        :m_name(name),m_age(age)
    {

    }
public:
    string m_name;
    int m_age;
};

#endif // OTHER_H

main.c

#include <iostream>
#include "Other.h"
using namespace std;
/****** 程序的执行顺序(初始化顺序) **************
 * 1.自上而下
 * 2.从左往右
 * 总结:初始化列表不会影响正常初始化顺序
 * 总结:析构顺序与初始化顺序相反
 * *****************************************/
int main()
{
    /*1.实例化People */
    People people; // C -> D -> A -> B -> People

    Student stu("张三",18);
    cout << stu.m_name << "\t" << stu.m_age << endl;

    return 0;
}/* 调用析构: ~People -> ~B -> ~A -> ~D -> ~C */

5.

/******** 常量成员 ***************************************
 * 通过前面的铺垫,我们初始化列表专门给常量成员做初始化操作
 * 分类:
 *      常量成员属性：
 *          定义:在变量名之前加 const
 *          作用:只初始化赋值一次,以后无法更改,必须由 "初始化列表" 操作
 *      常量成员函数:
 *          定义:在函数参数后加 const
 *          作用:该函数不可修改类成员属性值,只可访问
 *              自己在函数中定义的变量可以修改
 *          注意:一般读取函数都会写成const常函数
 *
 *      常对象只能访问常函数,后面set容器存放的都会变成常对象
 * *****************************************************/

代码：

#include <iostream>

using namespace std;
/******** 常量成员 ***************************************
 * 通过前面的铺垫,我们初始化列表专门给常量成员做初始化操作
 * 分类:
 *      常量成员属性：
 *          定义:在变量名之前加 const
 *          作用:只初始化赋值一次,以后无法更改,必须由 "初始化列表" 操作
 *      常量成员函数:
 *          定义:在函数参数后加 const
 *          作用:该函数不可修改类成员属性值,只可访问
 *              自己在函数中定义的变量可以修改
 *          注意:一般读取函数都会写成const常函数
 *
 *      常对象只能访问常函数,后面set容器存放的都会变成常对象
 * *****************************************************/
class People
{
public:
    People():value(10)
    {

    }
public:
    /**** 成员属性 ****/
    const int value;
    int m_temp;
public:
    /**** 成员函数 ****/
    void Print() const
    {
        /* 访问 */
        cout << "value = " << value << endl;
        cout << "m_temp = " << m_temp << endl;
        /* 修改 */
        //m_temp = 500;
        /* 自定义函数变量可修改 */
        int xxx = 10;
        xxx = 50;
    }

    void SetTemp(int temp)
    {
        m_temp = temp;
    }
    int temp() const;
};


int main()
{
    People people;
    people.Print(); /* 调用 const 成员函数 */
    people.SetTemp(50);/* 调用 非const 成员函数 */

    const People peo;
    peo.Print();/* 调用 const 成员函数 */
    //peo.SetTemp(50);/* 调用 非const 成员函数 */ 报错: 常对象只能调用常函数

    return 0;
}


int People::temp() const
{
    return m_temp;
}

6.

/********** this 指针和空指针 *********
 * 都是指向到自己的指针
 * *********************************/

代码：

#include <iostream>

using namespace std;
class People
{
public:
    People(string name = "wu",int age = 0) : m_name(name),m_age(age){}    /* 构造函数 */
    void Print();
    void SetValue(int value);
public:
    string m_name;
    int m_age;
    int value;  /*注意这个成员*/
};

/********** this 指针和空指针 *********
 * 都是指向到自己的指针
 * *********************************/

void People::Print()
{
    /**** this指针案例 ****/
    cout << "name = " << this->m_name << endl;
    printf("this = %p\n",this);

    /**** 空指针案例 : 会造成同名问题,所以使用this指针解决*****/
    cout << "name = " << m_name << endl;
    cout << "value = " << value << endl;
}

/** 发现类成员属性名与函数参数名重名 **/
/** 根据调用优先级规则,谁定义得近调用谁**/
void People::SetValue(int value)
{
    /** 在这里设置会不产生任何效果:因为 value是栈自己定义的会随着销毁 **/
    value = value;
    /** 可以 使用this指针解决该问题 **/
    this->value = value;
}

int main()
{
    People people;
    people.SetValue(500);
    people.Print();

    People *ptr = &people;
    printf("ptr = %p\n",ptr);

    return 0;
}

7.

/********  静态成员特征 *********
 * 公有特征:
 *      1.可以通过对象 或 类名访问
 *      2.所有对象公用同一静态变量空间
 *
 * 静态成员属性:
 *      注意:类内声明,类外初始化
 *      常用:用作数据记录
 *      须知:
 *          1.所有对象共享同一份数据
 *          2.空间在编译阶段就已经分配
 *          3.静态成员不占用对象空间
 * 静态成员函数:类内声明类外实现也可以,类内实现也可以
 *      注意:静态成员函数不能使用非静态成员,所以也不能访问this指针
 *      常用:接口处理(数据集,固定参数"串口参数,摄像头参数,音频参数,网络参数等")
 *
 * ***************************/

代码：

#include <iostream>
#include <string>
using namespace std;

class People
{
public:
    People(){
        s_value++;
    }
public: /* 成员函数 */
    static void GetValue()  /* 静态成员函数 */
    {
        cout << "我是静态成员函数" << endl;
        cout << "s_value = " << s_value << endl;
        //cout << "m_value = " << m_value << endl; 报错:静态成员函数不能使用非静态成员
    }

    static string GetIP()
    {
        return "IPV4 192.168.1.100";
    }

    static int GetMax(int value1,int value2)
    {
        return value1 > value2 ? value1 : value2;
    }

public: /* 成员属性 */
    static int s_value;    /*静态成员属性:类内声明,类外初始化*/
    int m_value;
};
/********  静态成员特征 *********
 * 公有特征:
 *      1.可以通过对象 或 类名访问
 *      2.所有对象公用同一静态变量空间
 *
 * 静态成员属性:
 *      注意:类内声明,类外初始化
 *      常用:用作数据记录
 *      须知:
 *          1.所有对象共享同一份数据
 *          2.空间在编译阶段就已经分配
 *          3.静态成员不占用对象空间
 * 静态成员函数:类内声明类外实现也可以,类内实现也可以
 *      注意:静态成员函数不能使用非静态成员,所以也不能访问this指针
 *      常用:接口处理(数据集,固定参数"串口参数,摄像头参数,音频参数,网络参数等")
 *
 * ***************************/

/** 静态成员属性类外初始化 **/
int People::s_value = 0;


int main()
{
    /* 1.实例化对象 */
    //People people;

    /* 2.调用对象 */
    /* 2.1 实例对象调用静态成员 */
    //cout << people.s_value << endl;

    /* 2.2 通过类名调用静态成员 */
    //cout << People::s_value << endl;
    //People::GetValue();

    /* 2.3 通常静态成员属性做记录数据 */
    //cout << "当前女娲造人:" << People::s_value << endl;
    //{People people;}
    //cout << "当前女娲造人:" << People::s_value << endl;
    //{People people;}
    //cout << "当前女娲造人:" << People::s_value << endl;
    //{People people;}
    //cout << "当前女娲造人:" << People::s_value << endl;
    //{People people;}
    //cout << "当前女娲造人:" << People::s_value << endl;

    /* 2.4 通常静态函数做接口使用 */
    cout << People::GetIP() << endl;

    cout << People::GetMax(10,20) << endl;

    /* 2.5 静态成员不占用类空间 */
    cout << "sizeof(People) = " << sizeof(People) << endl;

    /* 3.销毁对象 */

    return 0;
}

_She001
关注
专栏目录
[学习笔记-C++篇]day10 标准库-实例
warningm_dm的博客
03-14 1186
c++复习训练
C++ 语言学习 day10 复习（2）
she666666的博客
11-23 383
复习2
C++ 语言学习 day15 复习 （7）
she666666的博客
12-01 1108
liunx 连接百度云 ，人脸匹配，C++新特性，异常，lambda 函数（匿名函数）
C++ 语言学习 day13 复习 （5）
she666666的博客
11-29 302
容器 vector deque list string
C++ 语言学习 day11 复习（3）
she666666的博客
11-24 433
复习： 继承，多态，虚析构，文件操作
C++复习day10
2301_79420799的博客
09-11 1196
智能指针
C++ 语言学习 day14 复习 （6）
she666666的博客
12-01 326
stack queue pair键值对 set 集合 map 地图 ， linux 摄像头监控
C++ 语言学习 day12 复习 （4）
she666666的博客
11-25 221
模板，模板类，模板类的继承，容器的使用
C/C++复习 day1
m0_52420323的博客
08-12 1140
摘要：C语言 C++ 学习笔记
C++复习Day1
BabyQ12138的博客
05-11 375
常量 标识符命名规则 1.不能是关键字 2.只能由字母、数字、下划线组成 3.第一个字符不能是数字 4.区分大小写 5.最好可以见名知意 数据类型存在的意义：给变量分配合适的内存空间 整型 short； int； long(64位是8)； long long； 2 4 4（8） 8 int a=5; sizeof(int); sizeof(a); 浮点型 float double 4 8 区别 float 7位有效数字 double 15-16位有效数字 float f1=3.14159f；//如
day1-code.rar_达内_达内 c++_达内培训
09-24
综上所述，这个压缩包"day1-code.rar"对于想要学习或复习C++编程的人来说是一个宝贵的资源。它提供了达内教育的专业指导，可以帮助学习者逐步理解C++的基本概念、语法规则，并通过实践加深对编程的理解。无论是初学...
C++复习
wuyufei_sun的博客
06-04 438
C#是微软推出的一种面向对象的编程语言，专门用于.NET平台，结合了C++的功能和Java是简洁性，。用于开发Windows桌面应用、Web应用、游戏开发等。最初是为Windows开发的，随着.NET Core和.NET 5的推出，变得更加跨平台性。Java是一种面向对象的编程语言，具有跨平台性和安全性等特点。用于开发Web应用、移动应用、游戏等领域，是完全跨平台的语言，可以在任何支持Java虚拟机（JVM）的操作系统上运行。C++是一种面向对象的编程语言，是c语言的扩展。
CSP考试复习：第一单元 C++语言基础 1.1 程序结构
zhengheda的博客
09-14 397
第一单元 C++语言基础 1.1 程序结构 (1) 程序框架  注释：注释有两种，一种是“//”，另一种是“/* … */”。“//”必须单独放置一行，或代码所在行 的后面；而“/*”、“*/”成对存在，可以插入到代码的任意位置。  引用头文件：在代码开头写“#include <头文件名>”。如果想引用自己的头文件，需要把尖括号（表 示只从系统目录搜索头文件）换成双引号（表示先从 cpp 所在文件夹搜索，然后再到系统文件夹搜索）。  命名空间：很多 C++的东西都要引用 s.
ORB-SLAM2源码学习：ORBextractor.cc：IC_Angle 利用灰度质心法求解关键点方向角
2301_76831056的博客
11-01 705
IC_Angle 利用灰度质心法求解关键点方向角并在computeOrientation函数中被调用计算图像中所有特征点的方向。
嵌入式通信协议：MODBUS简明学习笔记
weixin_73867577的博客
11-02 357
学习Modbus的简明学习笔记
软件测试学习笔记丨Vue常用指令-条件渲染（v-if）
最新发布
ceshiren_com的博客
11-05 501
v-show只是简单控制dom元素的display属性。v-if通过操纵dom元素来进行切换显示。
SPI通信详解-学习笔记
qq_45059758的博客
11-04 509
SPI通信
diffusion model 学习笔记
wubing's 博客
11-01 1004
郎之万公式: 描述了粒子做随机布朗运动 (粒子位置随时间变化的关系), 是一种 SDE, 描述了 由梯度力(即.即我们在无条件模型 DDPM 估计的噪声中添加一个微小的扰动(. 基本上,在采样一半时,基本上预测的。输出的是噪声的估计, 这个估计的噪声。通过上面的公式，我们可以知道，当知道。),就可以作为条件模型的噪声估计.首先,假设我们已经有了一个训练好的。: 每一步中保留的原始信号的比例。的计算有各种不同的方法，). 已经接近于真实的。)影响的系统的时间演化.也就是,我们训练的网络。
SAP ABAP开发学习——接口中间件（PI）
m0_64077397的博客
11-04 204
左侧的红圈表示没有被生成。
C/C++语言学习代码实践集
资源摘要信息:"学习C、C++语言时期所敲代码.zip" 知识点一：C语言基础 C语言是一种广泛使用的计算机编程语言，由Dennis Ritchie于1972年在AT&T的贝尔实验室开发。C语言以其高效、灵活的特点著称，它是许多现代语言...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值