C++基础1

一、形参带默认值的函数

C++基础1_第1张图片

二、inline内联函数 

        内联函数是一种在编译器处理时,将函数的实际代码插入到调用处的方法。通常,函数调用涉及一定的开销,包括保存和恢复调用现场、跳转到函数的代码位置等。而内联函数通过在调用处直接插入函数的代码,避免了这些开销,从而提高了程序的执行效率。

  1. 减少函数调用开销: 内联函数可以减少函数调用时的开销,尤其是对于简短的函数。

  2. 提高程序执行效率: 内联函数能够减少函数调用时的跳转和保存现场恢复现场的开销,有助于提高程序的执行效率。

  3. 避免函数调用开销: 在一些情况下,函数调用会引入额外的开销,如栈帧的创建和销毁。内联函数可以避免这些开销。

C++基础1_第2张图片

C++基础1_第3张图片

 三·函数重载

3.1 什么是函数重载:

        1 . 一组函数,其中函数名相同,参数列表的个数和类型不同,那么这一组函数就称作-函数重载

        2. 一组函数称的上重载必须在同一个作用域

        3. const 或者volatile 的时候,是怎么影响形参类型的

        4. 函数名相同,参数列表不同,仅返回值不同? 不是重载

3.2 为什么c++可以发生函数重载,c不行

        c++产生函数符号的时候,函数名+参数列表类型组成的。

        c产生函数符号的时候,由函数名决定的

3.2 请解释一下多态:

静态(编译时期的)多态:函数重载

动态(运行时期的)多态:

3.3 c调用c++  或c++调用c

        c++无法直接调用c,因为c++生成的函数符号和c生成的不一样,可以用

extern "C"{

    int sum(int a,int b);
}

          c无法直接调用c++

extern "C"{

    int sum(int a,int b);
}

        只要是c++编译器,都内置了_cplusplus这个内置宏

#ifdef _cplusplus
    extern "C"{
#endif
    int sum(int a,int b);
#ifdef _cplusplus
}
#endif

四、const

1.  const修饰的变量不能作为左值,初始化完不能被修改。

const的编译方式不同,在c中const就是当作变量来编译生成指令的,c++中,所有出现const常量名字的地方,都被常量的初始化替换。

2. 在c语言中,const修饰的量可以不用初始化(但是没啥意义) ,但也不是常量,叫做常变量

比如const int a =20 ;  int array[a]={}; 是错误的,不是常量。a作为左值不能被修改,但是可以通过其他方式修改,比如指针。

void main()
{ 
const int a 20;
int*p=(int*)&a;
*p=30;
 // 30 30 30
 printf("%d%d%d\n",a,*p,*(&a));
}
3. 在c++中,,const修饰的量必须初始化,叫做常量

const int a =20 ;  int array[a]={};这是对的。

void main()
{ 
const int a 20;
int*p=(int*)&a;
*p=30;
 // 20 30 20
// 出现a的地方,在编译阶段直接替换
 printf("%d%d%d\n",a,*p,*(&a));
}
void main()
{ 
int b =20;
const int a =b;
int*p=(int*)&a;
*p=30;
 // 30 30 30
// a为常变量,运行时候才能决定
 printf("%d%d%d\n",a,*p,*(&a));
}
4. const修饰的量常出现的错误:

        1.  常量不能直接作为左值

         2.  不能将常量的地址泄漏给一个普通的指针或者普通的引用变量

const int a =10;
int *p =&a;  // 这是不对的    int *   <= const int *
const int a =10;
cosnt int *p =&a;   整型常量指针  这是可以的,保证了a不会被改

 

5. const和一级指针结合

        cosnt修饰的是离它最近的类型

分为两种:       1.const修改指针指向, const int *p;

                        2. const修饰指针本身     int *const p;

const int *p; // *p 不能被赋值 , p = &b可以任意赋值
// 可以任意指向不同的int类型内存,但是不能通过指针间接修改指向内存的值

int const * p; // 同上

int *const p; // const 修改 int *   , p =&b 不能被修改  *p=20可以被修改
// 指针P现在是常量,不能再指向其他内存 , 但可以通过指针解引用 , 修改其指向内存的值

const int * const p;   *p = &b 和p 都不能被赋值

总结const 和指针的类型转换公式

 int *   < =    cosnt int *     错误   整型常量的地址 转换成变量 是错误的

const int *  <=    int *     正确    变量地址, 转成常量地址

int *const p;   // 如果const右边没指针,const不参与类型  ,直接是int *

下面这个是错误的,因为类型转换发生了错误和有a没有a没有关系 

int a= 10;
const int *p =&a;
int *q =p;
6  const和二级指针结合

C++基础1_第4张图片

const int **q;  // **q不能被赋值  *q 和q可以
int *const*q;   // *q不能被赋值   **q 和q可以
int ** const q; // q不能被赋值    **q 和*q可以

发生类型转换时候

int ** <= const int **;  错误的

const int ** <= int **; 错误的

 int ** <= int *const* 错误的是一级指针转换,看的是const*

int * const * <= int **  正确的的是一级指针转换

你可能感兴趣的:(c++,服务器,linux)