新增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;
}
