首页 > 编程语言 >标准C++ -- day02

标准C++ -- day02

时间：2023-08-22 18:55:48浏览次数：40  
标签：调用 const 函数 -- day02 C++ int num 构造函数

一、 函数重载
  1. 什么是函数重载

在同一作用域下，函数名相同，参数列表不同的函数构成重载关系

函数重载与返回值类型、参数名无关

与作用域是否相同，以及参数列表的数量、参数类型、常属性不同等有关

#include <iostream>
using namespace std;

void func(int num)
{
    cout << "int" << endl;
}

void func(int num,double d)
{
    cout << "int double" << endl;
}

int main(int argc,const char* argv[])
{
    func(1);
}
  1. C++是如何实现函数重载的

通过g++ -S 生成汇编代码可知，编译器会把函数的参数类型进行缩写后追加到函数名的末尾形成新的函数名，既是进行了换名操作，从而确保编译结果函数名不重复。

  1. extern "C"

因为通过C++编译器编译函数、调用语句时，会变成换名后的名字，但是项目中有可能需要去调用已经通过C编译器编译好的函数，它们是没有换名的，因此会调用失败。

因为大部分情况下，C编译好的文件无法重新使用C++编译器编译，所以只能想办法让C++编译器在调用C编译的函数时不要换名

通过 extern "C" {xxx} 让C++编译器按照C语言的格式编译函数，从而让调用语句与被调用函数名同名，这样就可以正确地调用C标准库、系统函数。

#include <iostream>
using namespace std;

extern "C"{
    void func(int num);
}
int main(int argc,const char* argv[])
{
    func(1);
}
  1. 重载和隐藏

重载：在同一作用域下，函数名相同，参数列表不同的函数构成重载关系

隐藏：在不同作用域下，函数名相同，构成隐藏关系

#include <iostream>
using namespace std;

void func(void)
{
         
}
namespace n1{
    void func(void)
    {

    }    
}

int main(int argc,const char* argv[])
{
    func(1);
}
  1. 参数类型不匹配

当调用函数时，编译器会优先调用类型最匹配最精确的版本函数，如果没有最正确的，则会先做类型转换后再匹配，但如果没有能够进行类型转换匹配的版本，最后也会报错。

但是不建议通过类型转换去调用函数，因为转换情况与编译器有关

二、 默认形参
  1. 什么是默认形参

在C++中可以给函数的参数设置默认值，当函数被调用时如果调用者提供了实参则使用实参调用，如果没有提供则使用默认值调用

#include <iostream>
using namespace std;

void func(int num = 88)
{
    cout << num << endl;
}

int main(int argc,const char* argv[])
{
    func();// 输出88
    func(10);// 输出10
}
  1. 默认形参要靠右

如果函数有多个参数，并设置了默认形参，要遵循从右往左依次设置默认形参

  1. 只能在函数声明中设置默认形参

如果函数声明与定义分开实现，只能在函数声明中设置默认形参，否则语法错误

  1. 默认形参可能会影响函数重载

如果对函数进行了重载，又设置了默认形参，调用时可能会有冲突和歧义，调用失败

因此对于重载过的函数设置默认形参时一定要谨慎

三、 内联函数
  1. 普通函数

普通函数会被编译成二进制指令存储在代码段中，调用语句会生成一条跳转指令，当程序运行到调用语句时，会跳转该函数在代码段中对应的位置执行，执行结束会返回。

  1. 什么是内联函数

内联函数也会被翻译成二进制指令，但调用语句不会生成跳转指令，而是直接把内联函数的二进制指令进行替换，就没有跳转和返回，而是直接执行二进制指令，这种函数称为内联函数

  1. 显式内联和隐式内联

  • 显式内联
    在函数的返回值前加 inline 该函数就以内联函数的机制调用

  • 隐式内联
    在结构、联合、类中的成员函数会自动被当做内联函数处理
    注意：如果在结构、联合、类中声明成员函数，但是在外面定义，则不会当作内联函数处理
    注意：函数是否被内联，由编译器，以及它的优化等级决定，加 inlink 只可能影响它的觉得
    注意：g++默认优化等级 -O -O1 下所有的内联函数都会当成普通函数处理
    在-O2 - O3的优化级别下，甚至普通函数都能会被当做内联函数处理
    c99 也支持 inline

#include <iostream>
using namespace std;

inline void func(void)
{
    cout << "我是显式内联" << endl;
}

struct Data{
    void func(void)// 隐式内联
    {

    }
    void func1(void);
}

void Data::func1(void)// 里面声明，外面定义,
{

}

int main(int argc,const char* argv[])
{
    func();
}
  1. 内联的适用条件

优点：节约了函数传参、跳转、返回的时间，提高代码的运行速度

缺点：当被多个位置调用时，那么二进制指令会被拷贝多份，产生冗余，导致可执行文件明显增加

适用条件：

  • 适合内容简单且同一位置频繁调用的函数(循环)

  • 不适合内容多，且多个位置、较少次调用的函数，因为节约的时间弥补不过牺牲的空间

  • 如果具备递归属性的函数，无法内联

  1. 内联函数和宏函数的相同的和不同点
    相同点：都是采用以空间换时间的策略提高程序的运行速度，减少函数调用跳转的耗时
    不同点：

    1. 宏函数不是真正的函数，只是语句替换，不会对参数进行检查，没有返回值，安全性低。

    2. 内联函数是真正的函数，严格检查参数类型，有返回值，安全性高。

四、 引用

  1. 什么是引用：引用就是一种取别名的机制

  2. 为什么要使用指针

  • 跨函数共享变量(输出型参数)

  • 提高传参效率 ，引用可替代，效率比指针还高，不拷贝字节

  • 配合堆内存使用

  • 配合字符串使用，string类可以替代

  1. 引用使用格式：

类型名&    别名 = 变量名;

#include <iostream>
using namespace std;

void func(int& num)
{
    num++;
    cout << num << endl;
}

int main(int argc,const char* argv[])
{
    int num = 10;
    int& hehe = num;    // 给num取别名hehe
    hehe = 88;
    cout << num << endl;// 88
    func(num);        // num = 89
}
  1. 什么情况下使用引用：

  • 跨函数共享变量，引用比指针更安全（无需直接操作地址空间、不存在空引用，也极少出现野引用问题）、也比指针更方便（无需取地址、解引用）

  • 提高传参效率，引用的效率比指针还高，指针要传递4/8字节的地址编号，引用一个字节都不需要传递，但是引用和指针一样，都有被修改的风险，因此为了保护目标需要增加 const 保护

#include <iostream>
using namespace std;

struct Student
{
    char str[40];
    char sex;
    int id;
}

void show_stu(const Student& stu)
{

}

int main(int argc,const char* argv[])
{
    Student stu = {"hehe",'w',1001};
    show_stu(stu);
    cout << stu.id <<endl;     
}
  1. 使用引用需要注意的问题：

  • 引用必须初始化，所以不存在空的引用

  • 可以引用右值，但是必须使用 const 修饰引用

  • 引用不能中途更改引用目标

  • 函数的返回值类型可以是引用类型，但是不能返回局部变量的引用

  1. 指针与引用的相同点，不同点

  • 相同点：

    1. 都可以跨函数共享内存，提高函数传参效率，也需要 const 保护

    2. 可以定义数组指针，也可以定义数组引用

    int arr[5] = {1,2,3,4,5};
int (*arrp)[5] = &arr;
int (&hehe)[5] = arr;
    1. 可以定义函数指针，可以定义函数引用
    void (*p)(void) = func;
fp();
void (&xixi)(void) = func;
xixi();

  • 不同点：

    1. 引用是一种取别名的机制，指针是一种数据类型

    2. 引用不需要额外的存储空间，指针需要4/8个字节用于存储内存地址

    3. 指针可以不初始化，引用必须初始化

    4. 指针有空指针，但没有空引用

    5. 指针可以更改指向的目标，引用不可以更改引用的对象

    6. 指针可以配合堆内存使用，引用不行

    7. 可以定义指针数组，但不能定义引用数组

五、 强制类型转换

C语言原来的强制类型转换依然可以在C++中继续使用 (新类型)数据

注意：强制类型转换都只是得到一个临时结果，数据原来的类型不会改变

为什么C++要重新设计强制类型转换？

因为C语言的强制类型转换虽然自由度高，但是非常危险

为什么C++之父设计强制类型转换设计得很复杂、使用很麻烦？

因为他认为只有在程序设计不合理的情况下，才需要强制类型转换，之所以设计复杂，就是不想让程序员使用，而是去反思、重新设计自己的代码

  1. 静态类型转换
static_cast<目标类型>(原数据)
// 目标类型和原数据类型之间必须有一个方向能够自动类型转换，否则出错
int main()
{
    int num = 65;
    cout << static_cast<char>(num) << endl;// A
    void* p = NULL;
    static_cast<int*>(p);   // 正常
    static_cast<int>(p);    // 报错
}
  1. 动态类型转换
dynamic_cast<目标类型>(原数据)
// 目标类型和原数据类型之间必须存在继承关系，并且目标类型必须是指针类型或引用类型，否则出现错误
struct Man{}
struct Student : public Man
{}
int main()
{
    Student* s;
    dynamic_cast<Man*>(s);
    //Student s;
    //dynamic_cast<Man&>(s);
}
  1. 去常类型转换
const_cast<目标类型>(原数据)
// 目标类型必须是指针或引用，且除了const属性外，其它都要相同，否则出现错误
int main()
{
    const int num = 65;
    const_cast<int&>(num);
    int* p = const_cast<int*>(&num);
    //修改 *p，num不改变，常量折叠
}
  1. 重解释类型转换
reinterpret_cast<目标类型>(原数据)
// 只能把整数转换成指针，或者把指针转换成整数，否则会出错
int main()
{
    int num = 65;
    cout << reinterpret_cast<short*>(num) << endl;// 0x41
}
六、 面向对象

面向过程：

  • 关注如何解决问题，以及解决问题的步骤

面向对象：

  • 关注的解决问题的“人” -- “对象”，以及实现能解决问题的“对象”

  • 抽象：先找出(想象)能解决问题的“对象”，分析该对象解决问题所需要的属性(成员变量)和行为(成员函数)

  • 封装：把抽象的结构封装成一个类类型(结构)，并给予类成员变量、成员函数设置相对应的访问控制权限(public\private\protected)

  • 继承：

    1. 在封装类之前先考虑现有的类是否能解决部分问题，如果有则可以通过继承，只需要在此基础上扩展即可，从而缩短解决问题的时间

    2. 把一个复杂的大问题拆分成若干个不同的小问题，给每个小问题设计一个类去解决，最后把这些类通过继承合并成一个能解决大问题的类

  • 多态：

    1. 发出一个指令，系统会根据实际情况执行不同的操作，这种特征称为多态一个(指令多种形态)

    2. 比如重载过的函数、当调用函数时会根据参数的不同调用不同的版本，具体调用哪个版本在编译期间可以确定，称为编译时多态

  • 注意：面向对象的细节的本质上还是面向过程，因此面向对象的思想不是解决问题的捷径，而是以更高的维度去思考问题

七、 类和对象
  1. 什么是类和对象

  • 类是程序员设计一种数据类型，里面包含有成员变量、成员函数

  • 对象是类的实例化，可以理解为使用类类型创建的变量，创建的过程叫做实例化

  1. 类的设计和对象的实例化
  • 类
class 类名
{
    成员变量; // 默认属性为 private 私有
public:
    成员函数;
}
  • 实例化
//方法1： 类名 类对象名;
//方法2： 类名* 类对象名_p = new 类名;
  1. 类的声明、实现、使用
1.在头文件中声明
class 类名
{
    成员变量; // 默认属性为 private 私有
public:
    返回值 成员函数名(参数列表);
}
2.在源文件中实现成员函数
返回值 类名::成员函数名(参数列表)
{
    // 在成员函数中可以直接使用成员变量、成员函数
    // 不需要使用 . ->来表示访问
}

注意：如果类的内容不多，也可以直接在头文件中把成员函数实现

使用：

// 文件 student.h
#ifndef STUDENT_H
#define STUDENT_H

class Student
{
    char name[20];
    char sex;
    int id;
    short age;
public:
    void init(const char* _name,char _sex,int id,short age);
    void show(void);

}

#endif // STUDENT_H


// 文件 student.cpp
#include <iostream>
#include <cstring>
using namespace std; 
void Student::init(const char* _name,char _sex,int id,short age)
{
    strcpy(name,_name);
    sex = _sex;
    id = _id;
    age = _age;
    cout << "我是init函数" << endl;
}
void Student::show(void)
{
    cout << name << " " << sex << " " << id << " " << age << endl;
}


// 文件 main.cpp
#include <iostream>
using namespace std; 
int main(in targc,const char* argv[])
{
    Student stu;
    stu.init("hehe",'w',1001,18);
    stu.show();
    // 使用堆内存
    Student* stup = new Student;
    stup->init("xixi",'m',1002,19);
    stup->show();
}
八、 访问控制限定符
private

  • 私有的，被它修饰的成员只能在类内访问，这是类的默认访问属性

  • 设置为私有的是为了对类进行保护，一般会把成员变量设置私有

public

  • 公开的，被它修饰的成员可以在任意位置访问

  • 一般会把成员函数设置公开

protected
  • 保护的，被修饰的成员只能在本类内和它的子类中访问，但不能在类外访问
九、 构造函数

什么是构造函数

  • 构造函数就是与类名同名的成员函数，当实例化对象时，它会自动执行

  • 当构造函数执行结束后，对象才能完成实例化

  • 任务：一般负责对类对象进行初始化、资源的分配

class 类名
{
    int* p;
public:
    类名(参数)
    {
        p = new int;
    }
}

  • 构造函数必须是 public ，否则无法创建对象

  • 构造函数可以重载，可以有多个版本的构造函数(无参、有参）

  • 带参数的构造函数的调用
    类名 对象名(实参);                    // 使用实参调用有参构造
    类名* 对象名 = new 类名(实参);// 使用实参调用有参构造

  • 默认情况下编译器会自动生成一个什么都不干的无参构造函数，但一旦显式地实现了构造函数，就不再自动生成该无参构造函数了

  • 如果给有参构造设置了默认形参，实例化对象时可以出现类似调用无参构造的语句，但实际是调用了有参构造

  • 构造函数没有返回值

  • 不能使用 malloc 给类对象分配内存，因为不会调用构造函数

// class.cpp
#include <iostream>
using namespace std; 
class Test
{
public:
    Test(void)
    {
        cout << "我是Test的无参构造" << endl;
    }
    Test(int num)
    {
        cout << "我是Test的有参构造 " << num <<endl;
    }
}
int main(in targc,const char* argv[])
{
    Test t;
    // 初始化 Test t();
    Test* t1 = new Test;
    // 初始化 Test* t1 = new Test(88);
}
十、 析构函数

任务：析构函数一般负责对类对象内容进行收尾，例如：释放资源，保存数据等。

当类对象销毁时会自动执行

class 类名
{
    int* p;
public:
    类名(参数)// 构造函数
    {
        p = new int;
    }
    ~类名(void)// 析构函数
    {
        delete p;
    }
}

  1. 析构函数必须是 public

  2. 析构函数没有参数，没有返回值、不能重载

  3. 当类对象生命周期完结，被操作系统自动释放(栈)，或者通过delete手动释放(堆)才会调用析构函数

  4. 构造函数必定执行，但析构函数不一定会执行

  5. 不能使用free销毁类对象，因为不会调用析构函数

  6. 如果没有显式地实现析构函数，编译器也会自动生成一个什么都不做的析构函数

十一、 初始化列表

初始化链表属于构造函数的一种特殊语法，只能在构造函数中使用

class 类名
{ 
    const 成员1;
public: 
    类名(参数) :成员1(val),成员2(val) // 初始化语句
    { 
        // 成员1 = val; 属于赋值语句，不是初始化 带const属性的成员就无法赋值 
    } 
}

使用

#include <iostream>
using namespace std; 
class Test
{
    const int num;
public:
    Test(int num):num(num)
    {
 
    }
}
int main(in targc,const char* argv[])
{
    Test t(88);
}

注意：

  1. 初始化列表是先于构造函数执行，初始化列表执行时，类对象还没有实例化完成，因此它是一种给const属性成员变量初始化的最佳方案

  2. 当参数名与成员名相同时，初始化列表可以分辨出来，可以同名

  3. 当成员中有类类型，该成员的有参构造函数可以在初始化列表中调用

#include <iostream>
using namespace std; 
class Data
{
public:
    Data(int num)
    {
        
    }
}
class Test
{
    const int num;
    Data d;
public:
    Test(int num):num(num),d(10)//对Data类 d的初始化
    {
 
    }
}
int main(in targc,const char* argv[])
{
    Test t(88);
}

标签：调用,const,函数,--,day02,C++,int,num,构造函数
From： https://www.cnblogs.com/bigflyny/p/17649432.html

相关文章

  • 元组
    1.定义元组（Tuple）合并了不同类型的对象。2.使用lettom:[string,number];tom[0]='Tom';tom[1]=25;tom[0].slice(1);tom[1].toFixed(2);3.注意事项当直接对元组类型的变量进行初始化或者赋值的时候，需要提供所有元组类型中指定的项。lettom:[string,number......
  • windows 桌面GUI自动化-6. pywinauto 操作弹出文件选择框
    前言pywinauto操作弹出文件选择框，输入名称点保存场景点文件-另存为弹出系统的文件选择框，需要输入文件名称，点保存按钮文件选择框操作示例代码frompywinautoimportApplicationapp=Application('uia').start("notepad.exe")win=app.window(title_re="无标题-记......
  • 黑魂236 创建自己的playable
     前提是得下载并导入ResultPlayable。打开后就是自定义自己的Playable了第一个箭头指向自己Playable的名字，第二个箭头指向导演组件的导轨标签颜色，框起来都是可以自己定义的变量或者物件，最下面的框是可以在Unity右侧界面打开修改数值。 ......
  • LAMP搭建流程与应用
    LAMP搭建流程1、环境准备 [root@localhostopt]#systemctlstopfirewalld.service [root@localhostopt]#setenforce02、安装环境依赖包 [root@localhostopt]#yuminstall-y\ gcc\        #c语言编译器 gcc-c++\      #c编译......
  • 模拟集成电路设计系列博客——1.1.7 带有输出阻抗增强的宽摆幅电流镜
    1.1.7带有输出阻抗增强的宽摆幅电流镜下图的结构在[Gatti,1990]，[Coban,1994;Martin,1994]中被提出和使用，与[Säckinger,1990]的输出阻抗电流镜结构很像，除了一个二极管接法的晶体管被加在共源级增强放大器前作为电压转换器。在输出光，电平转换器是通过\(I_{bias}\)偏置的二......
  • day05
    进程管理一、进程的基本概念  1、进程与程序    程序是存储在磁盘上的可执行文件，程序被加载到内存中开始运行称为进程，一个程序可以同时加载成多个进程，进程就是处于活动状态下的程序  2、进程的分类    进程根据功能不同一般分为三种类型:交互进程、......
  • day01
    一、进程间通信-socket套接字  基本特征：socket是一种接口技术，被抽象成一种文件的操作，可以让同一计算机中的不同进程之间通信，也可以让不同计算机中的进程进行通信(网络通信)    本地进程间通信编程模型：        进程A         ......
  • 使用 Python ssh 远程登陆服务器的最佳方案
    在使用Python写一些脚本的时候，在某些情况下，我们需要频繁登陆远程服务去执行一次命令，并返回一些结果。在shell环境中，我们是这样子做的。sshpass-p${passwd}ssh-p${port}-l${user}-oStrictHostKeyChecking=noxx.xx.xx.xx"ls-l"然后你会发现，你的输出有很多你并不......
  • 安防视频监控平台EasyNVR平台启用国标级联的操作步骤来啦！
    安防视频监控汇聚EasyNVR视频集中存储平台，是基于RTSP/Onvif协议的安防视频平台，可支持将接入的视频流进行全平台、全终端分发，分发的视频流包括RTSP、RTMP、HTTP-FLV、WS-FLV、HLS、WebRTC等格式。为提高用户体验，让用户更加便捷的使用平台功能，本期小编来分享一个如何在EasyNVR平台上......
  • 18n使用
    1.安装npminstallvue-i18n@8//vue2使用vue-i18n@8vue3使用vue-i18n@92.在utils/lang下创建en-US.js,zh-CN.jsen-US.jsmodule.exports={index:{language:'language'}}zh-CN.jsmodule.exports={index:{language:'语言&#......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99