面向对象技术基础(C++)

1.函数的重载

• 当两个或者两个以上的函数共用一个函数名时，称为函数的重载。
• 在c语言中，函数名必须是唯一的，而在C++中函数可以重载，要求是函数参数的数据类型不同或者参数的个数不同或者参数的位置顺序不同。

注意：使用函数默认参数时使用函数重载容易造成错误

#include<iostream>
using namespace std;
//函数重载
//函数参数的数据类型不同，参数的个数不同，参数的位置顺序不同 
int square(int i){
	cout<<"调用的是第一个函数"<<endl;
	return i*i;
}
double square(double l){
	cout<<"调用的是第二个函数"<<endl ;
	return l*l;
}
void square(){
	cout<<"调用的是第三个函数";
}
int main()
{
	 cout<<square(10)<<endl;
	 cout<<square(1.5)<<endl;
	 square(); 
	return 0;
} 

2.作用域运算符“::”

• 通常情况下，如果有两个同名变量，一个是局部的，另一个是全局的，那么局部变量在其作用域内具有较高的优先权。它将屏蔽全局变量。
• 如果希望在局部变量的作用域内使用全局变量，可以在该变量前加“::”。“::”称为作用域运算符。、

#include<iostream>
using namespace std;
int a=10;//全局变量a 
int main(){
	int a=20;//局部变量a 
	cout<<a;
	return 0; 
}
//运行结果20

#include<iostream>
using namespace std;
int a=10;
int main(){
	int a=20;
	::a=25;
	cout<<a<<endl;
	cout<<::a<<endl;
	return 0;
} 

3.强制类型转换

• 在C语言中的表达式不同的数据类型会自动的转换数据类型，有时，还需要利用强制类型转换将不同的数据进行数据类型的转换。

int i=10;
double x=(double)i;

• C++另外提供了一种类似于函数调用的格式使之更加方便。

int i=10;
double x=double(i);

4.运算符new和delete

• C语言使用malloc函数和free函数动态分配内存和释放动态分配的内存空间，然而C++使用new和delete能更好的，更简单的进行内存的分配和释放。
• C语言中的方法仍然兼容。
• C++中利用new操作符在堆区开辟数据，堆区开辟数据，由程序员手动开辟，释放利用操作符delete。
• 利用new创建的数据，会返回该数据对应的类型的指针。

//指针变量名 =new 类型
int *p;//定义一个指针变量p
p=new int;//动态分配存放整形变量的内存空间，并把首地址赋值给指针变量

//delete 指针变量名
delete p;//将new动态分配的内存空间释放(内存的首地址一存放在指针变量p中)

优点：1.自动计算需要申请内存空间的大小(malloc运算符需要使用sizeof计算)
2.自动返回正确的指针类型(malloc需要使用强制类型转换)
3.可以进行重载
4.可以赋初值

#include<iostream>
using namespace std;
int* func(){
    int* p=new int(10);
    return p;
}

void test01(){
   int*p= func();
   cout<<*p<<endl;
   cout<<*p<<endl;//10  堆区数据由程序员管理释放
   delete p;

   //cout<<*p<<endl;
}


//利用new在堆区创建一个十个整形数据组成的数组
void test02(){
    int *arr=new int[10];
    int i;
    //遍历数组赋值
    for(i=0;i<10;i++){
        arr[i]=i+10;
    }
    //遍历数组打印
    for(i=0;i<10;i++){
        cout<<arr[i]<<endl;
    }
    delete[] arr;//释放堆区数组

    // for(i=0;i<10;i++){
    //     cout<<arr[i]<<endl;
    // }
}
int main()
{
    test01();
    test02();
    return 0;
}

5.引用

5.1.引用的概念

1. 建立引用的作用是给变量起一个别名，变量的引用通常可以认为是变量的别名，在说明一个引用时，必须同时用另一个变量的名字来给它初始化

2. 在声明引用时必须给他初始化，不能声明完以后在进行赋值。

3. 为引用提供初始值，可以是一个变量或者另一个引用。

4. 指针是通过地址间接的访问某个变量，而引用是通过别名直接访问。

5. 引用在初始化以后不能重新声明为另一个变量的引用。

6. 并不是所有的数据类型都可以使用引用，以下使用为非法的：

• 不允许建立void类型的引用
• 不能建立引用数组
• 不能建立引用的引用，不能建立指向指针的引用，引用本身不是一个数据类型，所以不能使用引用的引用，也没有引用的指针。
• 可以将引用的地址符给一个指针。
• 尽管运用运算符和地址操作符都使用&，但是两者是不同的，引用在声明是使用&，以后就像普通变量一样使用，其他场合都是地址操作符。

5.2.引用作为函数的参数

作用：函数传参时，可以利用引用的技术，让形参修饰实参

优点：可以简化指针修改实参

#include<iostream>
using namespace std;
//值传递
void swap01(int a,int b){
    int temp=a;
    a=b;
    b=temp;
    cout<<"swap01->a="<<a<<endl;
    cout<<"swap01->b="<<b<<endl;
}
//地址传递
void swap02(int* a,int* b){
    int temp=*a;
    *a=*b;
    *b=temp;
    cout<<"swap02->a="<<*a<<endl;
    cout<<"swap02->b="<<*b<<endl;
    //操作数据交换而不是地址交换，因为要保证函数体外部的实参被修改
}


//引用传递
void swap03(int &a,int &b){
    int temp=a;
    a=b;
    b=temp;
    cout<<"swap03->m="<<a<<endl;
    cout<<"swap03->n="<<b<<endl;
}
int main()
{
    int a=2,b=3;
    swap01(a,b);
    //值传递形参不会修饰实参
    cout<<"a="<<a<<endl;
    cout<<"b="<<b<<endl;

    swap02(&a,&b);
    cout<<"a="<<a<<endl;
    cout<<"b="<<b<<endl;

    int m=10,n=20;
    swap03(m,n);
    cout<<"m="<<m<<endl;
    cout<<"n="<<n<<endl;
    return 0;
}

5.3.使用引用返回函数值

• 使用引用做函数的返回值，采用这种方法可以将函数调用放在赋值运算符的左面。

#include<iostream>
using namespace std;
int a[]={1,2,3};
int &index(int);//声明一个返回整数类型的引用
int main()
{
    cout<<index(2)<<endl;
    index(2)=20;//将函数调用放在赋值运算符的左边，等价于给a[2]赋值
    cout<<index(2)<<endl;
    return 0; 
}
//定义函数返回一个整数类型的引用
int &index(int i){
    return a[i];
}

除了函数定义为返回一个引用外，通常一个函数是不能放在赋值运算符的左边的。

5.4引用的注意事项

引用的注意事项：

1，引用在定义的时候必须初始化

2，引用一旦初始化就不可以修改

#include<iostream>
using namespace std;
//引用的注意事项：
int main()
{
    int a=10;
    //1.引用在定义的时候必须初始化
    int &b=a;
    //2.引用一旦初始化，不可以修改
    int c=20;

    b=c;//赋值操作，不是更改引用
    cout<<a<<endl;
    cout<<b<<endl;
    cout<<c<<endl;
    return 0;
}