C++学习笔记2

• 二、C++基础知识

6、inline内联函数

在函数定义前冠以关键字 inline， 则该函数就被声明为内联函数

每当程序中出现对该函数的调用时， C++编译器使用函数体内的代码代替函数调用表达式。再编译过程替换

使用内联函数代替宏定义， 可以消除宏定义的不安全性。 内联函数具有宏定义的所有优点而没有缺点

浪费空间、节省时间

简单函数可以加上inline

7、缺省参数的函数

C++ 在声明函数原型时， 可为一个或多个参数指定缺省参数值， 以后调用此函数， 若省略其中某一参数， C++
自动的以缺省值作为相应参数的值

int special(int x=5,float y=5.3);

当进行函数调用时， 可以有以下几种形式

1)special(100,79.8)//x=100， y=79.8

2)special(25);//x=25， y=5.3

3)special();//x=5,y=5.3

不能special(，25);  这是错误的 

传实参的时候必须从左往右传，在设置缺省值的时候必须从右往左设置，有默认值的参数放在右边；没有缺省值的参数必须传参

#include<iostream>
using namespace std;
//函数声明， 缺省值在声明处设置
int my_add(int x=10,int y=20);
int main()
{
    cout<<"my_add()= "<<my_add()<<endl;
    cout<<"my_add(100)= "<<my_add(100)<<endl;
    cout<<"my_add(100,200)= "<<my_add(100,200)<<endl;
    return 0;
} 
//定义函数： 一般不设置缺省值
int my_add(int x,int y)
{
    return x+y;
}

8、函数重载

在传统 c 语言中， 函数名必须是唯一的， 程序中不允许出现同名的函数; 同一范围内C++中允许出现同名的函数， 这种现象称为函数重载， 是 C++的多态特性之一

只要函数参数的类型不同， 或者参数的个数不同， 或者两者兼而有之， 两个或两个 以上的函数可以使用相同的函数名

函数的重载与返回值没有关系

可以通过调用的参数类型不同决定使用哪个函数

也可以通过传的参数的个数不同决定使用哪个函数

当重载遇上缺省参数：需要人为避免

如果有函数重载， 尽量少些缺省参数。 如果有缺省参数， 尽量少写函数重载

#include<iostream>

using namespace std;

int myAdd(int x, int y = 10);
int myAdd(int x, int y, int z = 100);

int main()
{
	int sum1, sum2;
	//sum1=myAdd(10,20);//错误 这样计算机就不知道调用两个参数的 myAdd 还是三个参数的 myAdd
	//函数重载存在二义性
	// cout<<"sum1= "<<sum1<<endl;
	sum2 = myAdd(100);//正确， 只能调用两个参数的 myAdd
	cout << "sum2= " << sum2 << endl;
	return 0;
}

int myAdd(int x, int y)
{
	cout << "in int myAdd(int x,int y) fun" << endl;
	return x + y;
}

int myAdd(int x, int y, int z)
{
	cout << "in int myAdd(int x,int y,int z) fun" << endl;
	return x + y + z;
}

重载函数是根据参数个数或参数类型类确定调用哪一个重载版本的

int mul(int x,int y);

double mul(int x,int y);

这样是不能重载的， 重载是根据参数的个数及类型决定的

一般而言， 重载函数应执行相同的功能

9、强制类型转换

.c 语言中使用形如 (int )x 的形式

C++中还允许另一种形式：int(x)

以上两种方法 C++都能接受， 推荐使用后一种方法

---

补：

int num=10;//c 的变量初始化风格

int num(100);//c++的变量初始化风格

#include<cstdlib>//以 c 开头， 代表 c 语言的库文件

---

10、new和delete运算符

相当于C语言中的malloc和free

 

在申请内存的同时可以为该内存空间赋初值

#include<iostream>
int main()
{
    int *p1=new int(10);//将 new 申请的空间的内容初始化为 10
    *p1=100;
    cout<<"*p1= "<< *p1 <<endl;
    delete p1;
    return 0;
}

不允许数组在new时初始化；释放数组的时候前面加[]

int main()
{
    int i;
    int *p=new int[5];
    for(i=0;i<5;i++)
        p[i]=i;
    for(i=0;i<5;i++)
        cout<<p[i]<<", ";
    cout<<endl;
    delete []p;//注意释放数组的时候， 前面加[]
    return 0;
}

使用 new 动态分配内存时， 如果没有足够的内存时， 将返回空指针(NULL)

11、引用

引用就是给一个变量一个别名， 使指针运算更加方便

定义：类型名 &别名=变量名或别名 

    如：int a=5; int &b=a,int &c=b;

引用在定义的同时就必须赋值，能先定义后赋值

#include<iostream>
using namespace std;
int main()
{
    int num=10;
    int &data = num;//data 就是个引用， 在定义的时候必须就赋值， data 就是 num 的别名
    cout<<"&num = "<<&num <<endl;
    cout<<"&data= "<<&data<<endl;
    data=100;
    cout<<"num = "<<num <<endl;
    cout<<"data= "<<data<<endl;
    return 0;
}

引用作为函数的参数，可直接改变主调函数中变量的值

通过引用参数产生的效果同按地址传递是一样的，C++中主张用引用取代传地址的方式

#include<iostream>
using namespace std;
void setNum(int &x);
int main()
{
    int num=0;
    cout<<"start:num= "<<num<<endl;
    setNum(num);
    cout<<"end:num= "<<num<<endl;
    return 0;
} 
void setNum(int &x)//x 是引用， 就是主调函数中传进来的变量的别名， main 中 num 的别名
{
    x=100;//通过引用来改变主调函数中变量的值
}

引用作为函数的返回值，返回你返回的那个变量的别名

#include<iostream>
using namespace std;
int a[]={1,3,5,7,9};
int &index(int);
int main()
{
    index(2)=25;
    cout<<index(2)<<endl;//输出 25
    cout<<a[2]<<endl;
    return 0;
} 
int &index(int i)
{
    return a[i];
}

#include<iostream>
using namespace std;
int num = 100;
int &index(void);
int main()
{
    cout<<num<<endl;
    index() = 200;
    cout<<num<<endl;//输出 200
    cout<<index()<<endl;
    return 0;
} 
int &index(void)
{
    return num;
}

 

来源：CSDN

作者：妖孽__

链接：https://blog.csdn.net/LF_1845529754/article/details/104138998