C++数组与指针的使用方法

1. 指针的概念
变量的地址称为该变量的指针，存放指针的变量称为指针变量。
指针变量是一种变量，它存放其他变量的地址值。如
  int i;
  int *pi=&i;
  则pi变量的值就是变量i的地址。

指针前面加*,表示指针所指向的内存单元。如

  int i,j;
  int *pi;
  pi=&i;
  i=9;
  j=*pi;

  则此时j和i的值相同
指针变量是一种4字节的变量，任何类型的指针变量，在Win32平台下，它占用的内存大小均为4个字节,如

  int *pi;
  char *pch;
  double *pf
  WORD *pw;
  则sizeof(pi)==sizeof(pch)==sizeof(pf)==sizeof(pw)

  
指针变量本身的值改变，并不会引起它原来指向的变量的值发生改变。如

  int i,j;
  int *pi;
  i=8;
  pi=&i;
  j=9;
  pi=&j;

  则i的值始终为8 
通常情况下，不允许直接为指针赋常量值。为防止调用未初始化的指针，通常在未给指针赋值之前，
将指针初始化未NULL;

  int *pi=NULL; (正确)
  pi=(int *)0x30405060;(不适宜)

指针可以作为函数的参数,如

  void Swap(int *pi1,int *pi2)
  {
   int iTemp=*pi1;
   *pi1=*pi2;
   *pi2=iTemp;
  }
  int i,j;
  i=1;
  j=2;
  Swap(&i,&j);

分析下面函数

  void Swap(int *pi1,int *pi2)
  {
   int *iTemp=pi1;
   pi1=pi2;
   pi2=iTemp;
  }

指向指针的指针。指向指针的指针同样是一种指针变量，同样占用4个字节，只不过它存放的值是其他指针的地址，它用 **表示，如
 

int iData;
  int *piData;
  int **ppiData;                                                                   
  iData=100;
  piData=&iData;
  ppiData=&piData;
  cout<<**ppiData<

2. 指针的运算
指针变量加/减一个整数n，所得值仍然为指针，表示指针向前/向后移动n个元素如
 

int i=0x0f30348a;
  int *pi;
  char *pch=(char *)(&i);
  char *pch2=pch+1;
  pi=(int *)pch+1;

两个指针变量相减，表示两个指针之间的元素的个数，两个指针变量相减，则指针变量类型必须相同，如

  int i=0x0f30348a;
  char *pch=(char *)(&i);
  char *pch2=pch+1;
  int iEleCount=pch2-pch;

两个指针间相加，无实际意义。
两个指针的比较，表示两个指针指向的变量的地址的比较。两个指针的类型必须相同。如         

  char ch1='a';
  char ch2='b';
  char *pch1=&ch1;
  char *pch2=&ch2;
  cout<<(pch1>pch2)<

 
3. 引用
引用是给变量名取一个别名，对引用的使用完全等价于对原有变量的使用。在声明一个引用变量的同时，必须对其进行初始化，初始  化后，引用不能再作为其他变量的引用，如

  int i,j;
  int &iAlias=i;
  &iAlias=j; (错误)
例1：
  int a=10;
  int &b=a;
  a=a*a;
  cout<   cout<   cout<<&b< 例2：
  void Swap(int &a,int &b)
  {
   int iTemp=a;
   a=b;
   b=iTemp;
  }

引用声明与地址操作符的区别。当&前面有类型标识符时，它必然是对引用的声明，如int &i,除此之外都是取变量的地址，如   cout<<&i;

4. 数组
数组是一组具有相同数据类型的有序数据的集合，在内存中表现为一块连续的存储区域。引入数组可以大大减少程序中变量的数量， 使程序精练，而且数组含义清楚，使用方便，明确反映了数据间的关系。
4.1. 一维数组
定义一维数组的一般格式为
类型标识符 数组名[常量表达式];
如

  int iQuantitys[10];
  int iQuantitys[2*5];
  int iQuantitys[2*n];

表示数组个数的表达式必须为常量表达式。
引用数组元素的表示形式为
数组名[下标]
下标可以是结果为整型的常量或者表达式。
 

int iRands[7];
  for(int i=0;i<7;i++)
  {
   iRands[i]=int(rand());
   cout<   }
  cout<   for(i=6;i>=0;i--)
  {
   cout<   }
  cout<

一维数组的初始化
1、在定义数组时，用{}给数组赋予初值,{}内元素的个数不能多于声明中的元素个数，但是可以比声明中的元素个数少，没有初始化 的元素将赋值为0。

  int iArray[4]={1,2,3,4};
  int iArray[4]={1,2,3,4,5}; //(错误)
  int iArray[4]={0};
  char szText[4]={0};

2、在对全部数组元素赋初值时，可以不指定数组的长度，如
 

int iArray[]={1,2,3,4};

可以通过
 

int iCount=sizeof(iArray)/sizeof(int)；

求出元素的个数
3、给数组所有元素赋相同的初值。
 

char szText[8];
  int iArray[3];
  memset(szText,0,sizeof(szText));
  memset(szText,’a’,sizeof(szText));
  memset(iArray,0,sizeof(iArray));
  memset(iArray,9,sizeof(iArray));//(容易产生问题！)

示例，冒泡法排序

int a[10];
int i,j,t;
cout<<"input 10 numbers:"< for(i=0;i<10;i++)
  cin>>a[i];
cout< for(i=0;i<9;i++)
{
  for(j=0;j<9-i;j++)
  {
   if(a[j]>a[j+1])
   {
    t=a[j];
    a[j]=a[j+1];
    a[j+1]=t;
   }
  }
}
cout<<"the sorts numbers:"< for(i=0;i<10;i++)
  cout< cout< 练习：
int iArray[]={1,2,3,7,8,9};

//
将iArray数组的元素反序存放。

二维数组
定义二维数组的一般形式为
类型标识符 数组名[常量表达式][常量表达式]
例如
double fMatrix[M][N];
二维数组可以看作是一个M行N列的表格，也可以看成是一个有M个元素的一维数组，该数组的每个元素也是一个一维数组.
在内存中，多维数组同样是一片连续的存储区域，理解下面数组的存放顺序

int iMx[2][3]={{1,2,3},{2,5,6}};

二维数组的初始化
1、可以在声明数组时用{{}{},,,{}}的方式赋初值,如

int iMx[2][3]={{1,2,3},{2,5,6}};

2、可以按一维数组的方式赋值

int iMx[2][3]={1,2,3,2,5,6};

3、可以对行或者列部分赋值

int iMx[2][3]={{1},{2,5}};

4、如果对数组全部赋初始值，则行的大小可以省略，列的大小不能省略，如

int iMx[][3]={{1,2,3},{2,5,6}};//正确
int iMx[2][]={{1,2,3},{2,5,6}};//错误

5. 数组与指针
5.1. 字符数组，字符串
字符串是最后一个元素值为0的字符数组。

char szText1[6]={'h','e','l','l','o',''};
char szText2[]={'h','e','l','l','o',''};
char szText3[6]={"hello"};
char szText4[]={"hello"};
char szText5[]="hello";
char *ps教程zText6="hello"; //注意与 char szText5[]="hello";的区别
char szNames[][8]={“li”,”zhang”,”wang”};
char *pszNames[]={“li”,”zhang”,”wang”};
练习
char szTitle[]=”I love this game”;
char ch2dArray[9][2];
char ch2dArray2[3][6];

//
1、将szTitle中的字符依次填入ch2dArray数组中(按ch2dArray[0][0],ch2dArray[0][1],,,的顺序),
不够的用0填充。
2、把ch2dArray的元素依次赋给ch2dArray[3][6];
5.2. 数组与指针
数组名代表数组中的第一个元素的地址，可以将该地址赋值给同数据类型的指针，指针赋值以后，可以按照数组名的方式使用，也可  以按照原有指针的方式进行访问。

char szText[]="hello";
char *pszTemp;
pszTemp=szText;
cout<<"by array:"< cout<<"by pointer array:"< cout<<"by pointer:"<<*(pszTemp+1)<

5.3. 数组与指针示例

// PointerAndArray.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include
#include
using namespace std;
int main(int argc, char* argv[])
{
int i,j;
/********************************************************************
可以将0赋值给指针，表示为空指针，但是不许用其他整数给指针赋值
********************************************************************/
void *p=0; //或p=NULL;
//void *p=2; 错误
/********************************************************************
将数组地址赋值给指针时，用数组名和数组名取地址效果是一样的。
********************************************************************/
int iArray[]={1,2,3};
p=iArray;
p=&iArray;
/********************************************************************
指针变量存储内存单元的地址，通过指针变量对内存地址的访问必须
先知道指针变量的类型。比如用字符指针访问整型变量的各部分的指
********************************************************************/
int i1=123;
char *pCh1=(char *)(&i1);
*(pCh1+1)=3;
/********************************************************************
二维的整型数组,表示有2行、3列。在内存中是按顺序线性排列,
所以等效地当作2*3个元素的一维数组。
********************************************************************/
int i2dArray[2][3]={{1,2,3},{4,5,6}};
/********************************************************************
同样是2维的整型数组，如果在定义的时候赋值，行下标可以由
编译系统自动计算出来,如果定义的时候没赋初值，则行下标不能省略。
********************************************************************/
int i2dArray2[][3]={{1,2,3},{4,5,6}};
/********************************************************************
数组之间不允许直接赋值,可以通过内存块拷贝或单个元素循环赋值的方式拷
贝数组中的值
********************************************************************/
//int i2dArray3[2][3];
//i2dArray3=i2dArray; //错误
/********************************************************************
可以通过强制类型转换，用指针访问二维数组。
sizeof操作符计算出来的是整个数组的大小。
********************************************************************/
int *pi1;
pi1=(int *)i2dArray;
cout<<"n================用线性的方式访问整数=============="< for(i=0; i   cout< /********************************************************************
下面声明的是一个数组，该数组有2个元素，每个元素是一个整型的指针
********************************************************************/
int *piArray[2];
for(i=0; i<2; i++)
  piArray[i]=i2dArray[i];
cout< cout<<"n================用指针数组的方式访问整数=============="< for(i=0; i<2; i++)
{
  for(j=0; j<3; j++)
  {
   cout<<*(piArray[i]+j)<<" ";
   //或cout<<*(*(piArray+i)+j)<<" ";
  }
  cout< }

/********************************************************************
下面声明的是一个指向整型指针的指针变量，
该指针的值是(整型变量指针的地址)。
********************************************************************/

int **ppi;
ppi=&(piArray[0]);
cout<<"n================用指针的指针方式访问整数=============="< for(i=0; i<2; i++)
{
  for(j=0; j<3; j++)
  {
   cout<<*(*(ppi+i)+j)<<" ";
   //或cout<<*(*(piArray+i)+j)<<" ";
  }
  cout< }

/********************************************************************
下面声明的是一个指针变量，该指针指向的变量是具有3个元素的数组变量。
********************************************************************/

int (*piArray2)[3];
piArray2=&iArray;   //将一个一维数组变量的地址赋给piArray2
piArray2=&(i2dArray[0]); //将一个二维数组的的第一个一维数组变量的制止赋值给piArray2
//或piArray2=i2dArray;
cout<<"n================用数组指针的方式访问整数=============="< for(i=0; i<2; i++)
{
  for(j=0; j<3; j++)
  {
   cout<<(*(piArray+i))[j]<<" ";
  }
  cout< }

/********************************************************************
下面表示有3行3列字符的二维字符数组或者有3个元素的字符串数组。
********************************************************************/

char szArray[3][3]={"aa","bb","cc"};
char szArray2[][3]={"aa","bb","cc"};
cout<<"n================用2维数组的方式访问字符串=============="< for(i=0; i<3; i++)
  cout< cout< /********************************************************************
下面表示一个指针数组，该数组存放的是字符数组的指针或者说是字符串的指针。
(分析与szArray[3][3]内存布局的差异。以及pszArray和pszArray2的差异)
********************************************************************/
char *pszArray[]={"aa","bb","cc"};
char *pszArray2[]={"aa","bbbbb","cc"};
cout<<"n================用指针数组的方式访问字符串=============="< for(i=0; i<3; i++)
  cout<<*(pszArray2+i)<<" ";
cout< /********************************************************************
下面表示一个指针，该指针指向的是字符数组变量,字符数组的大小为3个字节
(注意访问方式与指针数组相同)
********************************************************************/
char (*pszArray3)[3];
pszArray3=szArray;
cout<<"n================用数组指针的方式访问字符串=============="< for(i=0; i<3; i++)
  cout<<*(pszArray3+i)<<" ";
cout< /********************************************************************
下面表示一个指向字符指针的指针变量，或者说是指向字符串的指针
(注意访问方式与上面两种仍然相同)
********************************************************************/
char **ppsz;
ppsz=pszArray;
cout<<"n================用指针的指针的方式访问字符串=============="< for(i=0; i<3; i++)
  cout<<*(ppsz+i)<<" ";
cout< /********************************************************************
最后查看各种变量本身的大小，并自己手工测试对不同的变量怎么赋值进去。
********************************************************************/
return 0;
}