您现在的位置是：首页 >技术杂谈 >c++的概述（二）网站首页技术杂谈

新增bool类型

bool的变量只能赋值为true (非0) 或false (0)

#include <iostream>

using namespace std;


int main(int argc, char const *argv[])
{
    bool num;
    num = true;
    cout<<"true = "<<true<<endl;
    cout<<"false = "<<false<<endl;
    
    return 0;
}

三目运算符功能增强

C语言的3目运算符 a>b ? a:b

a>b ? a:b返回的是a或b的值。

1 (a>b ? a:b) = 100;//错误

C++语言的3目运算符 a>b ? a:b

a>b ? a:b返回的是a或b的引用（a或b的变量名）

1 (a>b ? a:b) =100;//ok

c++引用

引用的本质：给已有的变量名 取个别名

1、引用的定义方式：

//给num取个别名为b

 int num =100;

 //&不是取b的地址 只是描述b是num的别名 编译器不会为b开辟新的空间

 int &b = num;  //num的别名 是b

 //操作b等价操作num

#include <iostream>

using namespace std;

int main(int argc, char const *argv[])
{
    int num = 10;
    int &b = num;

    cout<<"num = "<<num<<endl;
    cout<<"b = "<<b<<endl;

    //b和num  占用同一块空间
    cout<<"&num = "<<&num<<endl;
    cout<<"&b = "<<&b<<endl;
    return 0;
}

 定义步骤：

1、&修饰别名

2、给哪个变量取别名 就定义哪个变量

3、从上往下 整体替换

案例1：给数组取别名

1 int arr[5] ={1,2,3,4,5};

2 int (&new_arr)[5] = arr;

#include <iostream>

using namespace std;

void tets()
{
    int arr[5] = {1,2,3,4,5};
    int (&new_arr)[5] = arr;

    cout<<sizeof(new_arr)<<endl;
    cout<<new_arr[2]<<endl;
}


int main(int argc, char const *argv[])
{
    
    tets();

    return 0;
}

 2、引用必须初始化

int &b;  //非法的

 3、引用一旦确定是谁的别名 就不能更改

int num = 10;

int &b = num;

int data = 20;

b=data;  //千万不要认为是b给data取别名 仅仅是将data的值赋值b也就是data赋值num

 4、引用作为函数的参数 可以替代指针变量

#include <iostream>

using namespace std;


void swap_int01(int a1, int b1)
{
    int tmp = a1;
    a1 = b1;
     b1 = tmp;
 }
 void swap_int02(int *a1, int *b1)//a1=&a, b1=&b
 {
    //*a1 == a, *b1 == b
    int tmp = *a1;
    *a1 = *b1;
    *b1 = tmp;
 }
 void swap_int03(int &a1, int &b1)//int &a1 = a, int &b1=b
 {
    //a1 == a, b1 == b
    int tmp = a1;
    a1 = b1;
    b1 = tmp;
 }

 void test07()
 {
    int a = 10;
    int b = 20;

    cout<<"a = "<<a<<", b = "<<b <<endl;
    //swap_int01(a, b);//交换 不成功
    //swap_int02(&a, &b);//交换 成功
    swap_int03(a, b);//交换 成功
    cout<<"a = "<<a<<", b = "<<b<<endl;

 }

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

 引用作为函数的参数的好处：

1、函数内部 直接通过引用操作外部变量的值

2、省去了指针的操作

3、函数的形参不会拥有新的空间（节约了空间）

5、常引用

1 int &a = 10;//err

#include <iostream>

using namespace std;


void tets4()
{
    //a就叫常引用 不能通过a修改空间的值
    const int &a = 10;//ok
    cout<<"a = "<<a<<endl;//10
}

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

常引用 一般作为函数的参数 防止函数内部修改外部空间值

#include <iostream>

using namespace std;


//常引用 作为函数的参数 即节约了空间 又防止函数内部修改外部变量的值
void printf_num(const int &a)
{
    //a = 1000;//err
    cout<<" num = "<<a<<endl;
}

 int main(int argc, char *argv[])
 {
    int num = 10;  
    printf_num(num);
    return 0;
 }

6、引用作为函数的返回值类型

 1、通过函数返回值 在外界操作 函数内部申请的空间

#include <iostream>
using namespace std;

int& get_data(void)
{
    static int data = 100;
    //不要返回 普通局部变量的 引用
    return data; //返回谁 外界的a就给data取别名
}

int main(int argc, char const *argv[])
{
    int &a = get_data();
    cout<<"data = "<<a<<endl;
    return 0;
}

c++内联函数

 1、inline修饰的函数就是内联函数。

inline int myAdd(int x, int y)//inline必须出现在函数的定义处

{

        return x+y;

 }

内联函数为了继承宏函数的效率，没有函数调用时开销，然后又可以像普通函数那样，可以 进行参数， 返回值类型的安全检查，又可以作为成员函函数。

内联函数：是在编译阶段 完成的替换。

2、内联函数的特点：

1、能保证参数的完整性

2、有作用域的限制，可以成为类的成员

3、类中的成员函数 默认都是内联函数（不用inline）

 内联函数的要求：

不能存在任何形式的循环语句 不能存在过多的条件判断语句 函数体不能过于庞大 不能 对函数进行取地址操作。

内联仅仅只是给编译器一个建议。

 3、宏函数和内联函数的区别

• 宏函数： 预处理阶段完成替换、没有出入栈的开销、不能保证参数的完整性、没有作用域限 制、不能作为类的成员
• 内联函数： 编译阶段完成替换、没有出入栈的开销、能保证参数的完整性、有作用域限制、能 作为类的成员

c++(默认参数)缺省参数

1、默认参数的定义

c++在声明函数原型的时可为一个或者多个参数指定默认(缺省)的参数值，当函数调用 的时候如果没有传参，编译器会自动用默认值代替

函数的默认参数值，即在定义参数的时候同时给它一个初始值。在调用函数的时候，我们可以省略含有默认值的参数。也就是说，如果用户指定了参数值，则使用用户指定的值，否则使用默认参数的值。

#include <iostream>
using namespace std;

int my_add(int a,int b = 100)
{

    return a+b;
}

int main(int argc, char const *argv[])
{
    cout<<my_add(10,20)<<endl;
    cout<<my_add(10)<<endl;
    return 0;
}

 2、默认参数的注意点

 函数的默认参数从左向右，如果一个参数设置了默认参数，那么这个参数之后的参数都 必须设 置默认参数

1 int fun(int a, int b, int c=10);//正確

2 int fun(int a, int b=20, int c=10);//正確

3 int fun(int a=30, int b=20, int c=10);//正確

4 int fun(int a, int b=20, int c);//不正确

3、默认参数一般在函数声明的时候 设置 

#include<iostream>
using namespace std;
int main()
{
	double add(double a=3.2,double b=9.6);//在函数声明时设置默认参数
	cout<<add()<<endl;         //使用默认参数
	return 0;
}
double add(double a=3.2,double b=9.5)//在定义函数时设置默认参数
{
	return a+b;
}

c++函数的占位参数

C++中函数的形参列表里可以有占位参数，用来做占位，调用函数时必须填补该位置

//函数的占位参数，只输入数据类型，不用写变量名
//void func1(int a, int )//第二个int为占位参数，如果调用这个函数，必须传入参数（包括占位参数的值）
void func1(int a, int=10)//函数的占位参数也能有默认参数
{
	cout << "this is func1" << endl;
}
int main()
{
	func1(10, 20);//调用，如果没给默认参数就得输入
	func1(10);//给了就可以不用输入
}

#include<iostream>
using namespace std;

int fun(int a,int){        //第二个int位占位参数，就相当于没给形参起名字 
                        //形参的作用范围就那个 （）内
return a;
} 

int main(){
	 
    cout<<fun(10,10)<<endl; //调用的时候必须传两个值 

    return 0;
}