C++入门 ( 一 )-CSDN博客

本文链接：https://blog.csdn.net/clingu/article/details/138260146

C++入门 ( 一 )

1. 缺省参数

1.1 定义

缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参。

1.2 使用

1.2.1 全缺省

#include <iostream>
using namespace tsd;

void Func1(int a = 1) //单个形参
{
    cout << a << endl;
}

void Func2(int a = 1, int b = 2, int c = 3)//多个传参
{
    cout << a << endl;
    cout << b << endl;
    cout << c << endl;
}

int main()
{
    Func1();   //不进行传参, 此时a为缺省值 1
    Func(10);  //进行传参,此时 a 为传过去的参数 10 , 而不使用缺省值
    
    Func2(10,20,30);
    Func2(10,20);
    Func2(10);
    Func2();
    
    // 必须按顺序传参, 不能跳跃传参
    //Func2(10, , 30); //该语句会报错
    
    return 0;
}

1.2.2 半缺省

只能从右往左缺省 ( 这样不会存在歧义 )

#include <iostream>
using namespace std;

void Func(int a, int b = 20, int c = 30)
{
	cout << a << endl;
    cout << b << endl;
    cout << c << endl;
}

int main()
{
    //Func();     //此时未给a缺省值, 必须要给它传一个参数, 不然就会报错
    Func(1);
    Func(1,2);
    Func(1,2,3);
    return 0;
}

2. 函数重载

C语言中不允许重名函数的存在, 而C++中却支持, 究竟是因为什么呢, 让我们来一探究竟吧!

2.1 函数重载概念

函数重载 : ** 在同一作用域下声明几个功能类似的同名函数**, 这几个同名函数参数的形参列表(参数个数或类型或类型顺序)不同, 常用来处理功能类似的应用

#include <iostream>
using namespace std;

// 1、参数类型不同
int Add(int left, int right)
{
    cout << "int Add(int left, int right)" << endl;
    return left + right;
}
double Add(double left, double right)
{
    cout << "double Add(double left, double right)" << endl;
    return left + right;
}

// 2、参数个数不同
void f()
{
	cout << "f()" << endl;
}

void f(int a)
{
	cout << "f(int a)" << endl;
}

// 3、参数类型顺序不同
void f(int a, char b)
{
	cout << "f(int a,char b)" << endl;
}

void f(char b, int a)
{
	cout << "f(char b, int a)" << endl;
}

int main()
{
    
    Add(10, 20);
    Add(10.1, 20.2);
    
    f();
    f(10);
    f(10, 'a');
    f('a', 10);  
    
    //调用时不能有歧义, 不然会报错~
    //只要满足就构成重载, 但是构成重载也有可能调用歧义
    
    //返回值不同无法区分, 因此返回值不是重载的条件!
    
    return 0;
}

2.2 为什么C语言不支持重载, C++支持重载

在链接时 :

C语言直接用函数名去寻找函数, 而**C++是用修饰后的函数名（带上函数的参数）**去寻找, 故而支持重载

3. 引用

3.1 引用的概念

引用就是取别名

#include <iostream>
using namespace std;
int main()
{
    int a = 0;
    
	int& b = a;
	int& c = a;// 可以给一个变量取多个别名
	int& d = b;// 可以给别名取别名
    
    d++;// 此时 a,b,c,d 均 +1, 本质指向同一片空间, 地址相同
    
    return 0;
}

3.2 引用的特性

引用在定义时必须初始化

一个变量可以有多个引用
引用一旦引用一个实体, 再不能引用其他实体
void TestRef()
{
   int a = 10;
   int b = 20;
   // int& ra;   // 该条语句编译时会出错
   int& ra = a;
   int& rra = a;
   // ra = b;   // 该条语句也会出错
   printf("%p %p %p\n", &a, &ra, &rra);  
}

3.3 常引用

注意权限是否被放大 / 缩小

可以缩小, 但是不可以放大!

void TestConstRef()
{
   const int a = 10; 
   //int& ra = a;   // 该语句编译时会出错，a为常量
   const int& ra = a;
   // int& b = 10; // 该语句编译时会出错，b为常量
   const int& b = 10;
   double d = 12.34;
   //int& rd = d; // 该语句编译时会出错，类型不同
   const int& rd = d;
}

3.3 引用和指针的区别

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。
int main()
{
   int a = 10;
   int& ra = a;
   cout<<"&a = "<<&a<<endl;
   cout<<"&ra = "<<&ra<<endl;
   return 0;
}
在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。
int main()
{
   int a = 10;
   int& ra = a;
   ra = 20;
   int* pa = &a;
   *pa = 20;
   return 0;
}
引用和指针的不同点:

引用概念上定义一个变量的别名，指针存储一个变量地址。

引用在定义时必须初始化，指针没有要求

引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体

没有NULL引用，但有NULL指针

在sizeof中含义不同**：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数**(32位平台下占4个字节)

引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

有多级指针，但是没有多级引用

访问实体方式不同，指针需要显式解引用，引用编译器自己处理

引用比指针使用起来相对更安全