C++基础1

一、形参带默认值的函数

二、inline内联函数 

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

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

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

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和二级指针结合

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 **  正确的的是一级指针转换