C++【4】指针与引用；数组指针；指针数组

/*
    指针变量作为函数参数
        函数的参数可以是指针类型，它的作用是将一个变量的地址传送到另一个函数中。
        指针变量作为函数参数与变量本身作为函数参数不同，变量作函数参数传递的是具体值。
        而指针作为函数参数传递的是内存的地址
*/

#include<iostream>  //C++ 标准输入输出流头文件
using namespace std;

void swapfunc(int *p1,int *p2)  //将地址里面的值进行交换
{
    int    temp = 0;
    temp = *p1;
    *p1 = *p2;     
    *p2 = temp;
}

int main()
{
    int a,b;
    int *pa,*pb;
    cout << "请输入 a b 的值："<<endl;
    cin  >> a >> b ;
    
    
    pa = &a;
    pb = &b;
    
    if (a<b)
        swapfunc(p1,p2)
    cout << "a=" << a   << ",b=" << b << endl;
    cout << *pa  << "," << *pb    <<endl;
    
    return 0;
}

指向数组元素的指针的定义与赋值

int a[10], *p;

p =  &a[0];  //数组第一个元素的地址

p = a; //直接用数组名赋值   p是变量 ，a 是常量

若数组元素为int型，则指向其的指针变量也对应为int型

如： int a[10];

则：int *p = a;         int  *p = &a[0];   //这是两种情况，且均为赋初值

通过指针引用数组元素

int a[10];

int *p =a;  //为指针变量赋初值

* p = 1；  a[0] = 1 ; //通过指针变量为数组元素赋值

C++规定，p+1指向数组的下一个元素，而不是下一个字节。

如： *（p+1） = 2;          a[1] = 2;

 *++p = 2;         p=p+1; //指针变量也重新赋值         *p=2;

#include<iostream>  //C++ 标准输入输出流头文件
using namespace std;

int main()
{
	 int a[5] = {12,30,66,55,22} 
	 int *p = a; //将数组的第一个元素首地址赋给指针变量p  p = &a[0]  12
	
	 cout << "a[0] =  " << *p << endl;
	  *p = 33;
	 cout  << "a[0]"  << *p <<  endl;
	 
	 cout << "结果为：" << *(p+1) << endl; // 30   
 	 
	return 0;
}

取地址与取值的区别 

#include <iostream>

using namespace std;

int main() 
{
    int  max  =   66;
    int  &remax =  max;

    cout << "max的地址是：" << &max << endl;
    cout << "remax的地址是：" << &remax <<endl;
    
    cout <<"\n\n max的值= " << max << endl;
    cout <<"remax的值= " << remax <<endl;

 return 0;
}

对引用类型的变量，说明以下几点：

1.引用在定义的时候要初始化。

int  &remax ; // 错误，没有具体的引用对象

int &remax = max ; //max是已经定义过的变量

2.对引用的操作就是对被引用的变量的操作。

3.引用类型变量的初始化不能是一个常数。

如：int &refl = 5 ；//是错误的

int &refl =i;

4.引用同变量一样有地址，可以对其地址进行操作，即将其地址赋给一指针

int a,*p;

int &m = a;   //&是变量的引用

p = &m;

*p = 10;   //&是变量的地址

5.可以用动态分配的内存空间来初始化一个引用变量

 float &reff  =  * new  float ;   //用new开辟一个空间，取一个别名reff

 reff = 200;                            //给空间赋值    

 cout << reff<<endl;;             //输出200

 delete &reff;                        //收回这个空间

6.指针与引用的区别：

（1）指针是通过地址间接访问某个变量，而引用是通过别名直接访问某个变量。

（2）引用必须通过初始化，而一旦被初始化后不得作为其它变量的别名。

ps:当 &a 的前面有类型符时（如int &a）,它必然是对引用的声明；如果前面无类型符（如cout<<&a),则是取变量的地址。

以下的声明是非法的：

(1).企图建立数组的引用                int &a[9];

(2).企图建立指向引用的指针        int &* p;

(3).企图建立引用的引用                int &&px;

7.对常量（用const声明）的引用

void main()

{

        const int &r = 8;  //说明r为常量，不可赋值

        cout <<"r= "<<r<<endl; 

        //r+=15 ;  //r为常量，不可作为赋值运算

        cout<<"r= "<<r<<endl; 

}

8.引用与函数

引用的用途主要是用来作函数的参数或函数的返回值

引用作函数的形参，实际上是在被调函数中对实参变量进行操作

void change(int &x,int &y)     // x,y是实参a，b的别名  
{
    int t; t=x; x=y; y=z;
}

void main(void)
{
    int a = 3, b = 5;
    change(a,b);          //实参为变量
    cout<< a << '\t' << b << endl; 
}

9.函数的返回值为引用类型

        可以把函数定义为引用类型，这时函数的返回值即为某一变量的引用（别名），因此，它相当于返回了一个变量，所以可对其返回值进行赋值操作。这一点类同于函数的返回值为指针类型。

#include<iostream>
using namespace std;

int a = 4;
int &f(int x)   //函数返回a的引用，即a的别名
{
    a = a + x;
    return a;
}

int main(int agrc,char *argv[])
{
    int t = 5;
    cout <<f(t)<<endl;
    f(t) = 20;
    cout <<f(t)<<endl;
    t = f(t);
    cout <<f(t)<<endl; 
    return 0;
}

10.const类型常量

        当用const限制说明标识符时，表示所说明的数据类型为常量类型。可分为const型常量和const型指针。

可用const限制定义标识符量，如：

const         int        MaxLine = 666；

const         float      Pi = 3.1415926;

用const定义的标识符常量时，一定要对其初始化。在说明进行初始化是对这种常量置值的唯一办法，不能用赋值运算符对这种常量进行赋值。如：

                MaxLine = 35;

#include<iostream>
using namespace std;

int main(int argc,char *argv[])
{
    int a = 3,b = 5 ;     
    const int *pa = &b;       //可以不赋初值
    pa = &a;                //指针变量可以重新赋值 
    cout << *pa <<endl;     //输出3
    // *pa = 10;            //非法，指针指向的内容不能赋值
    a = 100 ;                //变量可以重新赋值
    cout << *pa <<endl;      //输出100  
    
    return 0;
}

//即不可以通过指针对变量重新赋值