C到C++ 升级细节笔记

已于 2022-09-21 11:18:46 修改 177 收藏 1
分类专栏： C语言 文章标签： c++
于 2021-08-23 15:19:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42328389/article/details/119868180
版权 
还是唐老师的视频，还是老样子，既然看了学了，就做点笔记做点精简和总结，
以后有用得到的地方，也方便查找。本文章只有比较C与C++ 有联系的不同之处，并没有C++独有的内容。
..添加目录栏目 								2021/9/17

目录

1、C到C++的升级

变量定义

  • 所有的变量都可以在需要使用时再定义
int c = 0;
for(int i=1; i<=3; i++)
{
	for(int j=1; j<=3; j++)
		{
			c += i * j;
		}
}
  • register 关键字请求编译器将局部变量存储于寄存器中，C++ 依然支持，有自己的优化方式，C++ 中可以取得 register 变量的地址，如果有对变量取地址的操作，register 会直接忽略。 register 基本上使用中看不到，但是为了兼容C语言，鸡肋，形同虚设，不用！！！
  • 在C语言中，可以重复定义多个同名的全局变量， 在C++中，不允许定义多个同名的全局变量

C语言中多个同名的全局变量最终会被连接到全局数据区的同一个地址空间上，C++直接拒绝这种二义性的做法

struct关键字的加强

  • C语言中的struct定义了 一组变量的集合
  • C语言中struct 定义的 标识符 并不 是一种新的类型
  • C++ 中的 struct用于定义一个全新的类型
    在这里插入图片描述

int f() 和 int f(void)

  • C++中所有的 标识符都必须显示的声明类型
  • C语言中的 默认类型 在C++ 中是不合法的
    在这里插入图片描述

布尔类型

bool 是C++ 中的基本数据类型，可以定义bool类型的 全局变量，常量，指针，数组

三目运算符

在这里插入图片描述
C++对三目运算符做了什么？

  • 当三目运算符的 可能返回都是变量时，返回的是变量引用（引用的解释见第 3 大点，3、引用部分）
  • 当三目运算符的 可能返回中有常量时，返回的是值

2、进化后const的分析

C与C++中const的比较

在C语言中：
在这里插入图片描述

int main()
{
	const int c = 0;
	int* p = (int*)&c;
	*p = 5;
	printf("c = %d\n", c);//c语言中可以改变 c= 5，C++中 c= 0
	printf("*p = %d\n", *p);
	printf("End...\n");
	return 0;
}

在这里插入图片描述
在这里插入图片描述在这里插入图片描述

void f()
{
	#define a 3
	const int b = 4;
}
void g()
{
	printf("a = %d\n", a); //C++编译不会报错，这个地方编译器看到的a 是3
	printf("b = %d\n", b); //C++编译报错，编译器发现b作用域不在这里
}

编译器压根不知道 宏 的存在，预处理器直接进行了文本替换

关于const的疑问

在这里插入图片描述在这里插入图片描述

#include<stdio.h>
int main()
{
	const int x = 1;
	const int& rx = x;//rx代表一个只读变量，这个变量所对应的内存空间是编译器为x常量分配的空间
	
	int& nrx = const_cast<int&>(rx);//nrx 对应的空间 和 rx一直，但是他没有只读属性
    nrx = 5;
	printf("x = %d\n", x);
	printf("rx = %d\n", rx);
	printf("nrx = %d\n", nrx);
	printf("&x = %p\n", &x);
	printf("&rx = %p\n", &rx);
	printf("&nrx = %p\n", &nrx);

    volatile const int y = 2;      //不是真正意义上的常量
    int* p = const_cast<int*>(&y); //将y的地址的只读属性去掉 

    *p = 6;

    printf("y = %d\n", y);
	printf("p = %p\n", p);

    const int z = y; //编译不确定z的值，所以z是只读变量

    p = const_cast<int*>(&z);
    *p = 7;

    printf("z = %d\n", z);
    printf("p = %p\n", p);

    char c = 'c';
    char& rc = c;   // rc代表 c
    const int& trc = c;//const引用他的类型不同的话，他会得到一个新的只读变量 trc 

    rc = 'a';

    printf("c = %c\n", c);
    printf("rc = %c\n", rc);
    printf("trc = %c\n", trc);  

	return 0;
}

在这里插入图片描述

3、引用

引用的概念

在这里插入图片描述

  • 引用作为 变量别名 而存在，因此在一些场合 可以代替指针
  • 引用相对指针来说具有更好的 可读性 和实用性
void swap(int& a, int& b){
	int t = a;
	a = b;
	b = t;
}

const 引用

  • 在C++ 中可以声明 const 引用， const type& name = var；
  • const 引用 让变量拥有 只读属性 
int a = 4;
const int& b = a;
int* p =(int*)&b;

b = 5; //Error, 只读变量
*p = 5; //OK. 修改变量 a 的值
  • 当使用 常量 对 const引用进行初始化是，C++ 编译器会为常量值分配空间，并将引用作为这段空间的别名 使用常量对 const 引用初始化后将生产一个只读变量
#include <stdio.h>
int main()
{
    const int& b = 1;
    int* p = (int*)&b;
    printf("b = %d\n", b);
    printf("*p = %d\n", *p);
    printf("p =%p\n", p);
    // b = 5; //ERROR
    *p = 5;
    printf("b = %d\n", b);
    printf("*p = %d\n", *p);
    printf("p =%p\n", p);
    return 0;  
}

在这里插入图片描述

引用的本质

在这里插入图片描述

  • C++编译器在 编译过程中 用 指针常量 作为引用的 内部实现，因此引用所占的空间大小与指针相同。
  • 从使用的角度，引用只是一个别名，C++为了实用性而隐藏了引用的存储空间这一细节
  • 引用可以大多数情况下代替指针，可以尽可能的避开内存错误

关于引用的疑问
在这里插入图片描述在这里插入图片描述在这里插入图片描述

#include<stdio.h>
int a = 1;
struct SV
{
    int& x;
    int& y;
    int& z;

};
int main()
{
    int b = 2;
    int* pc = new int(3); 
    SV sv = {a, b, *pc};
    int& array[] = {a, b, *pc};//&array[1] - &array[0] = 应该是4，数组\
                                所以在C++里面不支持引用数组
    
    printf("&sv.x= %p\n",&sv.x);
    printf("&sv.y= %p\n",&sv.y);
    printf("&sv.z= %p\n",&sv.z);

    delete pc;
    return 0;
}

在这里插入图片描述

  • 指针是一个变量 引用是一个变量的新名字
  • const 引用能够生产 新的只读变量
  • 编译时不能直接确定初始值的 const 表示符都是 只读变量

4、内联函数

  • C++中推荐使用 内联函数替代宏代码片段
  • C++中使用 inline 关键字声明内联函数
inline int func(int a, int b)
{
	return a < b ? a : b;
}
  • C++编译器可以讲一个函数进行内敛编译，被C++编译器内敛编译的函数叫做 内联函数
  • C++编译器直接将函数体插入函数调用的地方
  • 内联函数 替代 宏定义更加安全 ， 宏代码片段由预处理器处理，进行简单的文本替换，没有任何的编译过程，因此可能出现副作用。
  • 内联函数 没有 普通函数调用时的 额外开销（压栈，跳转，返回）
  • inline只是一种请求，C++编译器 不一定满足函数的内联请求！！！
  • 现代 C++ 编译器 能够进行编译优化，一些函数及时没有 inline声明，也可能被内敛编译
  • 一些现代 C++编译器 提供了 扩展语法，能够对函数进行 强制内联，如：
    g++ :_attribute((always_inline)) 属性 (attribute后面也有一个__打不出来)
    MSVC： _forceinline
_attribute_((always_inline)) //g++
_forceinline       //MSVC

C++ 中 inline 内联编译的限制：

  • 不能存在任何形式的 循环语句
  • 不能存在 过多的条件判断语句
  • 函数体不能过于庞大
  • 不能对函数进行取址操作
  • 函数内敛声明 必须在调用之前

5、函数参数的扩展

  • C++中可以在 函数声明时 为参数提供一个默认值
  • 当函数调用没有 提供参数的值，则使用默认值
  • 参数的默认值 必须在 函数声明中指定
  • 参数的默认值必须 从右向左提供
  • 函数调用时 使用了默认值，则后续参数 必须使用默认值

在C++中可以为函数提供 站位参数

  • 占位参数 只有参数类型声明，而 没有参数名声明
  • 一般情况下，在函数体内部 无法使用占位参数
  • 占位参数与默认参数结合起来使用
int func(int x, int){
   return x;
}
//...
func(1,2); //ok

函数占位参数 为了 兼容C语言程序 中可能出现的不规范写法,看下面的例子：

void func(int = 0, int = 0){}

int main(int argc, char *argv[])
{
	func();
	func(1,2);
	return 0;
}

6、函数重载分析

函数重载（Function Overload）

  • 用同一个函数名定义不同的函数
  • 当函数名和 不同的参数搭配 时函数的含义不同
  • 函数重载 至少 满足下面的一个条件：
    参数 个数 不同
    参数 类型 不同
    参数 顺序 不同

当 函数默认参数 遇上 函数重载会发生什么？

#include<stdio.h>

int func(int a, int b, int c = 0){
	return a * b * c;
}
int func(int a, int b){
	return a + b;
}
int main(int argc, char *argv[])
{
	int c = func(1, 2);//编译器会报错，他不知道该调用什么 ERROR
	return 0;
}
  • 编译器最终寻找到候选函数不唯一，出现二义性，编译失败

函数重载的注意事项

  • 重载函数在 本质上是相互独立的不同函数 ，占用不同的地址
  • 重载函数的函数类型不同
  • 函数返回值不能作为函数重载的依据

函数重载是由 函数名 和 参数列表 决定的！！！

重载与指针

  • 严格匹配候选者的函数类型与函数指针的函数类型
  • 函数重载 必然发生在同一个作用域中
  • 无法直接通过函数名得到重载函数的入口地址，必须要还要根据函数指针类型或者参数列表

7、C++ 和 C相互调用

在这里插入图片描述

#include<stdio.h>

extern "C"
{
#include "add.h"
}
int main()
{
	int c = add(1, 2);
	...
}

在这里插入图片描述在这里插入图片描述

8、动态内存分配

专用关键字 new

  • C++中的动态内存分配可以 同时进行初始化
  • C++中的动态内存分配是 基于类型进行的
    在这里插入图片描述
p = new int[10]; //p指向的这段内存空间至少为 40字节，不能保证要多少给多少，可以保证至少这么多

在这里插入图片描述

#include<stdio.h>

int main()
{
    int* pi = new int(1);
    int* pa = new int[1];
    float* pf = new float(2.0f);
    char* pc = new char('c');
    
    printf("*pi = %d\n",*pi);
    printf("*pa = %d\n",*pa);
    printf("*pf = %f\n",*pf);
    printf("*pc = %c\n",*pc);

    printf("pi = %p\n",pi);
    printf("pa = %p\n",pa);
    printf("pc = %p\n",pc);

    delete pi;
    delete pa;
    delete pf;
    delete pc;

    return 0;
}

在这里插入图片描述

9、命名空间

在C语言中，所有的全局标识符共享同一个作用域，在大工程中标识符之间可能发生冲突

C++中提出了命名空间的概念

  • 命名空间将 全局作用域分为不同的部分
  • 不同命名空间中的标识符可以同名 而不会发生冲突
  • 命名空间可以相互嵌套
  • 全局作用域也叫 默认命名空间
//C++ 命名空间的定义
namespace Name
{
	namespace Internal
	{
	
	}
}

C++命名空间的使用：

  • 只用整个命名空间： using namespace name;
  • 使用命名空间中的变量： using name：：variable ;
  • 使用默认命名空间中的变量： ：：variable
#include<stdio.h>

namespace First
{
    int i = 0;
}
namespace Second
{
    int i = 1;

    namespace Internal
    {
        struct P
        {
            int x;
            int y;
        };
        
    }
}
int main()
{
    using namespace First;
    using  Second::Internal::P;
    
    printf("First::i = %d\n",i);
    printf("Second::i = %d\n",Second::i);
    
    P p ={2, 3};

    printf("p.x = %d\n",p.x);
    printf("p.y = %d\n",p.y);

    return 0;
}

在这里插入图片描述

10、新型的类型转换

C方式强制类型转换 过于粗暴（任意类型之间都可以进行转换），难于定位

C++将强制类型转换分为 4 种不同的类型
在这里插入图片描述

static_cast 强制类型转换

  • 用于 基本类型 间的转换
  • 不能 用于 基本类型指针 间的转换
  • 用于 有继承关系类对象 之间的转换 和 类指针之间的转换

const_cast 强制类型转换

  • 用于去除 变量的只读属性
  • 强制转换的 目标类型 必须是 指针 或 引用

reinterpret_cast 强制类型转换

  • 用于 指针类型间 的强制转换
  • 用于 整数 和 指针类型间的强制转换

dynamic_cast 强制类型转换

  • 用于有继承关系的类指针间的转换
  • 用于有交叉关系的类指针间的转换
  • 具有类型检查的功能
  • 需要虚函数的支持
#include<stdio.h>

void static_cast_demo(){
    int i = 0X12345;
    char c = 'c';
    int *pi = &i;
    char* pc = &c;

    c = static_cast<char>(i); //将i int类型转换成 char类型，OK 
    // pc = static_cast<char*>(pi);//整型指针 转换，Error
}

void const_cast_demo(){
    const int& j = 1;   //产生了一个只读变量
    int& k = const_cast<int&>(j);//将 j 的只读属性去掉，变成普通变量，用k来修改这个变量j 的值

    const int x = 2;   //产生了一个常量
    int& y = const_cast<int&>(x); // 这个去掉只读属性，但是x进入了符号表，编译器会为x分配了空间，\
                                     得到的内存里面为这个常量分配空间，y就是这个空间的别名

    // int z = const_cast<int>(x);//const_cast只能用于引用 和指针转换， Error

    k = 5;

    printf("k = %d\n", k);
    printf("j = %d\n", j);

    y = 8;
  
    printf("x = %d\n", x);
    printf("y = %d\n", y);
    printf("&x = %d\n", &x);
    printf("&y = %d\n", &y);
}

void reinterpret_cast_demo(){
    int i = 0;
    char c = 'c';
    int *pi = &i;
    char* pc = &c;

    pc = reinterpret_cast<char*>(pi);//OK
    pi = reinterpret_cast<int*>(pc);
    pi = reinterpret_cast<int*>(i);//将整形转换为指针，OK
    // c = reinterpret_cast<char>(i);//基本类型的转换，Error
}

void dynamic_cast_demo(){
    int i = 0;
    int* pi = &i;
    // char * pc = dynamic_cast<char*>(pi);//类指针之间，还需要有虚函数
}
int main()
{
    static_cast_demo();
    const_cast_demo();
    reinterpret_cast_demo();
    dynamic_cast_demo();
    return 0;
}

在这里插入图片描述

矜辰所致
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C/C++学习路线总结与分享
chenlycly的专栏
10-07 2万+
C/C++学习路线总结与分享
C++ API设计 笔记
木元心的博客
03-06 662
C++ API设计 笔记 什么是API API提供了对某个问题的抽象，以及客户与解决该问题的软件组件之间进行交互的方式 概括的说，API定义了一些复用的模块，使得各个模块化功能块可以嵌入到最终用户的应用程序中去 API是一个明确定义的接口，可以为其他软件提供特定的服务 契约 承包人 C++ API 通常会包含如下的元素： 头文件 一组.h头文件。头文件定义了接口，使得客户端代码能够针对该接口进行编译。开源API还包括API实现的源代码 类库 一个或多个静态库或动态库文件，它们提供了API的具体实现
Effective C++学习笔记
Ray
04-18 776
文章目录一 让自己习惯C++1:视C++为一个语言联邦2:尽量用const,enum,inline替换#define3:尽可能的使用const4:确定对象使用前已先被初始化二 构造/析构/赋值运算5:了解C++默默编写并调用哪些函数6:若不想使用编译器自动生成的函数，就该明确的拒绝7:为多态基类声明virtual析构函数8:别让异常逃离析构函数9:绝对不要在构造和析构过程中调用virtual函数10:令operator = 返回一个reference to *this11:在operator =中处理'自我
C++ API设计笔记
网络资源是无限的
03-29 5721
《C++ API设计》原英文版由Martin Reddy著，中文版出版于2013年，这里是中文版的笔记。 1. API简介 1.1 什么是API：API(Application Programming Interface)提供了对某个问题的抽象，以及客户与解决该问题的软件组件之间进行交互的方式。组件本身通常以软件类库形式分发，它们可以在多个应用程序中使用。概况地说，API定义了一些可复用的模块...
《Effective C++》笔记
weixin_42065178的博客
08-19 576
《Effective C++》笔记
从C到C++——C++新增和有变化的关键字
小嵌同学的博客
08-24 271
目录 1.4.1.本课程介绍和bool关键字 1.4.1.1、本课程介绍 (1)研究编程语言从关键字出发不适合学习，但是适合查漏补缺 (2)C++全部关键字列表查阅 (3)C++关键字相对C有几种情况：新增关键字、新增语义、语义变化、完全无变化 (4)限于面向对象和STL没学，因此本课程不追求全面讲解关键字，重点是从一些核心关键字出发学习C++语法特性，体会C++与C的不同，熟悉C++。 1.4.1.2、C++的bool关键字 (1)bool类型也叫逻辑类型，是个2值enum，值为true或false（这2
Effective Modern C++读书笔记
qq_36535265的博客
04-30 1144
本笔记主要用于记录要领、体会及摘抄书中精华 第1章 类型推导 1.1 理解模板类型推导 在模板类型推导过程中 具有引用（&）或指针（*）类型的实参会被当成非引用类型来处理。换言之，其引用或指针会被忽略。 template<typename T> void f(T& param); int x = 27; const int cx = x; const int& rx = x; f(x); // 此处T的类型被推导为int，param为int& f(.
C++头文件与实用笔记
XiaoFengsen的博客
03-07 1566
C++头文件加.h与不加.h，以及<>与""有什么区别？ c++中囊括了c，所以区分一下c和c++的语法很有必要，先上结论： < >：表示引用标准头文件，头文件是系统路径，编译器会先在系统目录下搜索； " "：表示使用自己写的头文件，编译器会先在用户目录下搜索，找不到再从系统库环境中找 不加 .h ：如果使用的是新的C++标准库，不加 .h。例如#include <iostream>，编程时要加上命名空间 加 .h ：如果是自己写的头文件，是必须加.h的。编程时不用再加
C++基础学习笔记
最新发布
qq_48639334的博客
09-08 206
C++ 是一种静态类型的、编译式的、通用的、大小写敏感的、不规则的编程语言，支持过程化编程、面向对象编程和泛型编程。1983年在贝尔实验室诞生，在发展阶段被称为“new C”，之后被称为“C with Class”，后来取名C++，++即C语言中的自增操作符，所以说C++是C的增强和完善版本。也就是构造的重载函数针对上面的A类如A(float c){a=c;}针对类的代码复用技术，提高开发效率，减少错误，让大规模代码开发的关注点转到软件结构上。所谓“继承”，就是。
C++ 笔记
ZhongUncle的博客
09-02 322
本文基于 C++ 11，适合有 C 语言基础的阅读，只讲与C语言不同的地方。如果需要了解最新式语法，那么可以去看微软 Visual Studio 2022 的文档《C++标准库参考（STL）》
C++重温笔记(一): C++再初识
Miracle8070
09-17 376
1. 写在前面 这段时间打算重新把c++捡起来， 实习给我带来的一个感触就是算法工程师， 真的得算法和工程两手抓，以解决问题为基础。而从语言的角度来看， 算法的话，必须熟练使用python，而工程方面， 我发现c++也是必备的， 就推荐领域来说， 大部分线上的服务全是c++，而我们所谓的模型，也一般是训练好部署上线然后提供接口而已。所以硬核语言(Java和C++)还应该再至少熟练使用一门，而如果我选的话，就暂时选择c++了。 和python一样， 这个系列是重温，依然不会整理太基础性的东西，更像是查缺补漏，
C++学习笔记08
云胡的博客
07-31 71
类型转换 构造函数：其他数据类型——>自定义数据类型 类型转换函数：自定义数据类型——>其他数据类型 但一般情况下不要使用 类型转换函数特点 是成员函数 没有返回值类型 在函数体内以传值形式返回一个目标类型的变量(对象) PIMPL设计模式 简介 是一种常用的用来对“类的接口和实现”进行解耦的方法，以避免在头文件中暴露私有细节。但PIMPL并非严格意义上的设计模式，可看作是桥接设计...
[C++]Effective C++笔记
easycome easygoing、
08-17 513
Effective C++
【C++学习笔记】C++继承与派生
qq_41854911的博客
08-04 332
文章目录C++三种继承方式public、protected、private 修饰类的成员public、protected、private 指定继承方式改变访问权限C++继承时的名字遮蔽问题基类成员函数和派生类成员函数不构成重载C++类继承时的作用域嵌套，破解C++继承的一切秘密！C++继承时的对象内存模型继承时的内存模型有成员变量遮蔽时的内存分布C++基类和派生类的构造函数构造函数的调用顺序基类构造函数调用规则C++基类和派生类的析构函数借助指针突破访问权限的限制，访问private、protected属性
C/C++编程：C语言中的内联函数
OceanStar的博客
12-16 767
在C语言中，如果一些函数被频繁调用，不断地有函数入栈，即函数栈，会造成栈空间或栈内存的大量消耗。 为了解决这个问题，特别的引入了inline修饰符，表示为内联函数。 栈空间就是指放置程式的局部数据也就是函数内数据的内存空间，在系统下，栈空间是有限的，假如频繁大量的使用就会造成因栈空间不足所造成的程式出错的问题，函数的死循环递归调用的最终结果就是导致栈内存空间枯竭。 #include <stdio.h> //函数定义为inline即:内联函数 inline char* dbtest(
C+++笔记
Stream12138的博客
04-24 202
继承 get_basic() class Superior :public basic{ basic* get_basic() { return this; } }; is-a关系 is-a一般是继承关系 has-a一般是组合关系 宏定义 #ifndef π // 先测试π是否被宏定义过 #define π 3.1415926 //如果没有则定义并执行程序段1 //程序段1 #else //如果已经定义则执行程序段2 //程序段2 #endif 使用编译器通常的流程 .
翁恺老师全套C语言课程笔记（本菜鸟正在学习）
qq_65513579的博客
07-05 1470
本菜鸟正在学习翁恺老师，记笔记的同时顺便把笔记上传一哈。
【笔记】Effective C++ III
Antrn
01-03 162
03 尽可能使用const 允许程序员制定一个语义约束：不该被改动的对象，编译器会强制实施这项约束。 可以修饰指针自身、所指物，或两者都是（不是）const。 char greeting[] = "Hello ; char* p = greeting; // 指针不是const，数据也不是const const char* p = greeting; // 指针不是const，数据是const c...
C++笔记 静态库和动态库详解
weixin_40933653的博客
04-10 327
定义：运行时库 静态库 动态库 运行时库：Unix中一个典型的运行时库例子就是libc，它包含标准的C函数，如，print()，exit()等等，用户能创建他们自己的运行库（在Windows中是DLL），而具体的细节依赖编译器和操作系统的。 静态库：函数和数据被编译进一个二进制文件（通常扩展名为.lib），静态库实际上是在链接时被链接到EXE的，库本身不需要与可执行文件一起发行。 动态库：用VC++创建的动态库包含两个文件，一个lib文件和一个dll文件，这个lib文件就是引入库，不是静态库，引入库有时

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题：精致技术 设计师：CSDN官方博客 返回首页
评论

打赏作者

矜辰所致

您们的鼓励是我奋斗的动力！

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额：-- )
扫码支付
扫码支付：¥2
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值