您现在的位置是:首页 >学无止境 >c++学习之c++对c的扩展2网站首页学无止境

c++学习之c++对c的扩展2

万众☆倾倒 2023-05-12 20:11:22
简介const 修饰的对象为一个常量,不能被改变。

目录

1.c/c++中的const

1 const概述

2 c/c++中const的区别

c中的:

c++中的const:

c/c++中的const异同

c++中const修饰的变量,分配内存情况

尽量以const替换define

2.引用

函数的引用:

引用的本质

指针的引用

5 常量引用

内联函数

内联函数的基本概念

2 宏函数和内联函数的区别


1.c/c++中的const

1 const概述

const 修饰的对象为一个常量,不能被改变

2 c/c++中const的区别

c语言中的const1 const修饰的局部变量,存在栈区,虽然不能通过const修饰的变量去修改栈区内容,但是可以 通过地址去修改

 const修饰的全局变量是保存在常量区,不能通过变量名去修改.也不能通过地址去修改。

 const修饰的全局变量,如果其他文件想使用,直接extern声明外部可用即可。

c中的:

在main.c中

#include <stdio.h>
const int b = 10;//const修饰的全局变量保存在常量区

 void test03()
 {
 extern const int num;//声明num是外部可用的
 printf("num=%d
",num);

 }
 //const修饰的全局变量
 void test02()
 {
 //b = 100;
 int *p = &b;
 *p = 100;//错误的 不能修改常量区的内容
 printf("b=%d
",b);
 }
 //const修饰的局部变量
 void test01()
 {
 //在c语言中const修饰的变量保存在栈区
 const int a = 10;
 //a = 100;
 int *p = &a;
 *p = 100;
 printf("a=%d
",a);
 }
 int main()
 {
 test03();
 return 0;
 }

onst int num = 1;

c++中的const:

1 const修饰的局部变量赋值常量时,局部变量保存在符号表中,修改不了,是一个常量

2 const修饰的全局变量保存在常量区,不能被修改

3 const修饰的全局变量默认是内部链接属性,加上extern修饰变成外部链接属性

mian.cpp

#include <iostream>
 using namespace std;
 const int b = 1;

 void test03()
 {
 extern const int num;
 cout << num << endl;

 }
 void test02()
 {
 //const修饰的全局变量存在常量区
 int *p = (int *)&b;
 *p = 100;//错误的
 cout << b<< endl;

 }
 //c++中const修饰的局部变量
 void test01()
 {
 //c++中const修饰的局部变量存在符号表中
 const int a = 10;
 //a = 100;
 //对const修饰的局部变量取地址 编译器会产生一个临时变量来保存a的地址
 // int tmp = a; int *p = &tmp
 int *p = (int *)&a;
 cout << a << endl;
}
int main()
 {

 test03();
 return 0;
 }

extern const int num = 1;// const修饰的全局变量默认是内部链接属性.

c/c++中的const异同

相同的点:

c和c++中的const修饰的全局变量都是保存在常量区,不能被修改

不同的点:

c语言中const修饰的局部变量赋值为常量时,,局部变量保存在栈区,可以被指针修

c++中,const修饰的局部变量赋值为常量时,局部变量保存符号表中,不能被修改

c语言中const修饰的全局变量默认是外部链接属性

c++语言中const修饰的全局变量默认是内部链接属性

c++中const修饰的变量,分配内存情况

const修饰的全局变量在常量区分配了内存

对const修饰的局部变量赋值为常量时,对其取地址,会在栈区分配临时的内存空间

const修饰的局部变量赋值为变量时,局部变量保存在栈区

const修饰的局部变量时一个自定义变量,也是在栈区分配内存

只有一种情况,const'修饰的局部变量被赋值为常量时,这个局部变量保存在符号表中,

符号表后中的变量,编译器直接访问,不会为其开辟空间。

#include <iostream>
 using namespace std;
 const int a = 1;//const修饰的全局变量在常量区分配了内存
 void test01()
{
 const int a = 10;//const修饰的局部变量赋值为常量没有分配内存,存在符号化表中
 int *p = (int *)&a;//对const修饰的局部变量赋值为常量的变量取地址 会分配一个临
时的空间 int tmp =a *p =&tmp
 }
void test02()
 {
 int b = 2;
 //const修饰的局部变量赋值变量时 局部变量存在栈区
 const int a = b;
 int *p = (int *)&a;
 *p = 100;
 cout << a << endl;

 }
 struct stu
 {
 int a;
 int b;
 };
 void test03()
 {
 //const修饰的变量为自定义变量时,保存在栈区
 const struct stu obj = {1,2};
 struct stu *p = (struct stu *)&obj;
 p‐>a = 3;
 p‐>b = 4;
cout << obj.a << " " << obj.b << endl;
 }
 int main()
 {
test03();
return 0;

 }

尽量以const替换define

有两点原因:
1. const修饰的全局变量或const修饰的局部变量赋值为常量,是有类型的,而define的
宏没有 类型
2. const修饰的全局变量或const修饰的局部变量赋值为常量有作用域的,而define的
宏没有作用域
#include <iostream>
 using namespace std;
 namespace A
 {
 const int max = 1024;
 const short max1 = 1024;
 #define MAX 1024
 }
 // 宏没有作用域 宏没有类型(int)
 void fun(int a)
 {

 }
 void fun(short a)
 {


 }

 void test01()
 {
 cout << A::max << endl;
 cout << MAX << endl;
 fun(MAX);//void fun(int a)
 fun(A::max);//void fun(int a)

 fun(A::max1);//void fun(short a)
 }
 int main()
30 {
31
32 return 0;
33 }

宏定义的变量是做替换的,并且是全局的没有作用限制,但是const修饰的变量为常量是有范围的,范围即为原来变量的范围。

2.引用

引用的作用为给变量取别名。

引用的基本用法
原类型 &别名 = 旧名  这里的&不是取地址符,而是引用。

 

 在这里取别名后,两者的地址是一样的,且对a操作,b也会跟着操作。

注意事项:
引用一旦初始化,不能更改引用的指向
引用定义时必须初始化
不能引用NULL
引用可以引用任意类型包括数组
&在等号的左边是引用,在等号的右边是取地址
#include <iostream>
 using namespace std;
 void test01()
 {
 int a = 10;
 //引用一旦初始化之后不能改变引用的标识
 int &b = a;
 b = 100;
 cout << a << endl;
int c = 1;
 //b = c; 代表把c的值赋值给b 不是给c取别名为b
 //int &d; 引用定义时必须初始化
 }
 void test02()
 {
 int a[5] = { 1,2,3,4,5 };
 //int(&arr)[5] = a;
 typedef int ARR[5];
 //type & 别名 = 旧名
 ARR & arr = a;
 for (int i = 0; i < 5; i++)
 {
 cout << arr[i] << " ";

 }
 cout << endl;

 }
 int main()
 {
 test02();
return 0;

 }
变量的引用并不会为他开辟空间,只想相当于多了个名字。

函数的引用:

注意:
引用可以作为函数的形参
函数调用时 就是  &实参=形参  实参的改变影响形参,我们不用指针也可以做到这一点。
不能返回局部变量的引用
//指针方式交换
 void swap(int *x, int *y)
 {
 int tmp = *x;
 *x = *y;
 *y = tmp;
 }
 void test01()
 {
 int a = 10;
 int b = 20;
 swap(&a,&b);
 cout << a << " " << b << endl;

 }


//引用交换

 void swap_ref(int &x, int &y)// int &x =a, int &y =b)
 {
 int tmp = x;
 x = y;
 y = tmp;

 }
int main()
 {
 int a = 10;
 int b = 20;
 swap_ref(a, b);
 swap(&a,&b);
 }

引用的本质

引用的本质是一个指针常量
type &b = a; 编译器底层这么实现的:
type *const b = &a;
#include <iostream>
 using namespace std;
void test01()
 {
 int a = 10;
 int &b = a;//编译器优化 int* const b = &a
 //指针常量 不能改变指针变量的指向
 // b =0x100;

 b = 1000;// *b =1000

 }
 void fun(int *&q)//int *&q = p ==> 编译器 int * const q =&p
 {

 }

 void test02()
 {
 int *p = NULL;
 fun(p);

 } 

指针的引用

套用引用公式: type &q = p
假设:
type为指针类型
  void fun ( int * & q ) // int* &q = p
  {
  }
  void test ()
  {
  int * p = NULL ;
  fun ( p );
  }

5 常量引用

const type &p = q;
常量引用代表不能通过引用去修改引用标识的那块空间
#include <iostream>
 using namespace std;
 void test01()
 {
 int a = 10;
 // const修饰的是引用& 不能通过引用去修改引用的这块空间的内容
 const int &b = a;
 //b = 1000;//err
 }

 void test02()
 {
 //int &b = 100;//不能引用常量
 const int &b = 1;//int tmp =1 ,const int &b= tmp

 }
 int main()
 {

 return 0;
 }

内联函数

内联函数的基本概念

c++ 中,预定义宏的概念是用内联函数来实现的,而内联函数本身也是一个真正的函数。
内联函数具有普通函数的所有行为。唯一不同之处在于 内联函数会在适当的地方像预定义宏
一样展开,所以不需要函数调用的开销。 因此应该不使用宏,使用内联函数。 在普通函数 ( 非成员函数 ) 函数前面加上 inline 关键字使之成为内联函数。
但是必须注意必须
函数体和声明结合在一起,否则编译器将它作为普通函数来对待。
inline void func(int a);
以上写法没有任何效果,仅仅是声明函数,应该如下方式来做 :
inline int func(int a){return ++;}
注意 : 编译器将会检查函数参数列表使用是否正确,并返回值 ( 进行必要的转换 ) 。这些事预
处理器无法完成的。
但是函数调用就会占用空间:,但是内联函数相对于普通函数的优势只是省去了函数调用时候的压
栈,跳转,返回的开销。我们可以理解为内联函数是以空间换时间。
内联函数就是继承了宏函数的高效,并且不会出错,还可以当成类的成员函数用

2 宏函数和内联函数的区别

宏函数的替换是发生在 预处理阶段
内联函数的替换是发生在 编译阶段
宏函数容易出错,内联函数不会
内联函数和宏函数一样,都省去了调用函数的开销。
举个例子
//宏函数
#define MYCOMPARE(a,b) (a)<(b)?(a):(b)
//内联函数
 inline int mycpmpare(int a, int b)
 {
 return a < b ? a : b;
 }

 void test02()
 {
 int a = 1;
 int b = 5;
 //int c = MYCOMPARE(++a, b);// ++a<b?++a:b
 int c = mycpmpare(++a, b);
 cout << c << endl;

 }
类的成员函数默认编译器会将它做成内联函数
class Person{
public:
 Person(){ cout << "构造函数!" << endl; }
 void PrintPerson(){ cout << "输出Person!" << endl; }
 }

类里的成员函数默认为内联函数。

内联仅仅只是给编译器一个建议,编译器不一定会接受这种建议 ,如果你没有将函数声明为
内联函数,那么编译器也可能将此函数做内联编译。一个好的编译器将会内联小的、简单的
函数
风语者!平时喜欢研究各种技术,目前在从事后端开发工作,热爱生活、热爱工作。