c++学习1｜调用 缺省 函数重载

引用（别名）

int main(){
  int a{10};
  int& b =a;
  //错误->int&& c = b;//没有引用的引用
	return 0;
}

int main(){
  int a{10};
  const int b{20};
  // int& x =b;//error
  //改变x时 势必改变b的值 
  const int& x = b;//正确写法
  
  const int& y = a;
  //可以用y读取a的值，但不能修改
  const int& z = 10;
  //也可以
}

指针形式的交换函数

void Swap(int* ap,int* bp){
    assert(ap!=NULL&&bp!=NULL);
    int tmp =*ap;
    *ap =*bp;
    *bp = tmp;
} 
void main(){
    int x =10,y=20;
    Swap(&x,&y);
    cout<<"x= "<<x<<"y = "<<y<<endl;
    return;
 }

引用形式的交换函数

void Swap(int& a,int& b){
    int tmp =a;
    a =b;
    b = tmp;
} 
void main(){
    int x =10,y=20;
    Swap(&x,&y);
    cout<<"x= "<<x<<"y = "<<y<<endl;
    return;
}

引用可以改变数组元素

void main(){
    int a =10,b =20;
    int ar[5]{1,2,3,4,5};
    int& x = ar[0];
    x+=10;
}

数组的引用

void main(){
    int a =10,b =20;
    int ar[5]{1,2,3,4,5};
    int (&x)[5] = ar;
    x+=10;
}

指针的引用

void main(){
    int a{10};
    int ip =&a;
    int*& sp = ip;
    *sp = 100;
    sp = &b;
}

缺省值

从右向左依次给,不能跳着给

函数调用时，从左向右依次给，不能跳着给

void func(int a,int b, int c,int d=0,int e=0){
    printf("%d,%d,%d,%d,%d",a,b,c,d,e);
}
void main(){
    func(1,2,3,4,5);
    func(1,2,3);//d=0,e=0
    //func(1,2,,3,4);//error 不能跳着给
    return;
}

声明中给缺省，定义不要给

void func(int a,int b=0);
//void func(int ,int =0); //这样也可以
int main(){
    int x =10,y=20;
    func(x,y);
    return 0;
}
void func(int a,int b){
    int c = a+b;
    cout<<c<<endl;
}

调用随机函数

int my_rand(){
    srand(time(nullptr));
    int ra = rand() % 100;
    return ra;
}
void func(int a,int b = my_rand()){
    cout<<"a= "<<a<<endl;
    cout<<"b= "<<b<<endl;
}
void main(){
    func(1);//b给随机值
}

函数的重载

函数名相同，形参的类型或个数不同，也可以，就是函数的重载

在编译确定关系

int my_max(int a,int b){return a>b?a:b;}
char my_max(char a,char b){return a>b?a:b;}
double my_max(double a,double b){return a>b?a:b;}

void func(int a);
void func(int a,int b);

void func(int a,char ch);
void func(char ch,int a);

不能只拿函数类型进行重载

int func(int a,int b);
char func(int a,int b);
//error

指针与常性指针

普通指针优先和普通指针结合

void func(int* p);
void func(const int* p);

int main(){
    int a=10;
    func(&a);//优先func(int* p),未定义则func(const int* p)
    const int b =10;
    func(&b);//和func(const int* p) ,未定义则报错。
    return 0;
}

引用与常性引用

void func(int& a);
void func(const int& b);
int main(){
    int x =10;
    func(x);//func(int& a) ,未定义则与const结合
    const y =10;
    func(y);//func(const int& b),未定义则报错
    return 0;
}

怎么实现的函数重载

名字粉碎技术

将参数名作为函数名的一部分

调用规则

// __stdcall 回调调用规则

//__edecl c的调用规则

//__fastcall

// thiscall