C/C++指针与数组（一）

预备知识
1、数据的存储

2、基本内建类型
1）类型的大小

C++ offers a flexible standard with some guaranteed minimum sizes, which it takes from C:

• A short integer is at least 16 bits wide.
• An int integer is at least as big as short.
• A long integer is at least 32 bits wide and at least as big as int.
• A long long integer is at least 64 bits wide and at least as big as long.

Many systems currently use the minimum guarantee, making short 16 bits and long 32 bits.This still leaves several choices open for int. It could be 16, 24, or 32 bits in width and meet the standard. It could even be 64 bits, providing that long and long long are at least that wide.
参考：C++ Primer Plus Sixth Edition

#include<iostream>
using namespace std;
int main(int argc, char *argv[])
{cout << "sizeof(char)=" << sizeof(char) << endl;cout << "sizeof(short)=" << sizeof(short) << endl;cout << "sizeof(int)=" << sizeof(int) << endl;cout << "sizeof(float)=" << sizeof(float) << endl;cout << "sizeof(long)=" << sizeof(long) << endl;cout << "sizeof(long long)=" << sizeof(long long) << endl;cout << "sizeof(double)=" << sizeof(double) << endl;return 0;
}

2）类型代表的数据的大小

#include<iostream>
#include <climits> // use limits.h for older systems
using namespace std;
int main(int argc, char *argv[])
{char n_char = CHAR_MAX;short n_short = SHRT_MAX; // symbols defined in climits fileint n_int = INT_MAX; // initialize n_int to max int valuefloat n_float = FLT_MAX;long n_long = LONG_MAX;long long n_llong = LLONG_MAX;double n_double = DBL_MAX;cout << "Value Ranges:\tMinimum\t\t\tMaximum" << endl;cout << "char:\t\t" << CHAR_MIN << "\t\t\t" << CHAR_MAX << endl;cout << "short:\t\t" << SHRT_MIN << "\t\t\t" << n_short << endl;cout << "int:\t\t" << INT_MIN << "\t\t" << n_int << endl;cout << "float:\t\t" << FLT_MIN << "\t\t" <<  n_float << endl;cout << "long:\t\t" << LONG_MIN << "\t\t" << n_long << endl;cout << "long long:\t" << LLONG_MIN << "\t" <<n_llong << endl;cout << "double:\t\t" << DBL_MIN << "\t\t" << n_double << endl;return 0;
}

一、指向单一对象的指针和该指针的加减算术运算

#include<iostream>
#include <climits> // use limits.h for older systems
using namespace std;
int main(int argc, char *argv[])
{char chr;short sht = 1; // symbols defined in climits fileint in = 2; // initialize n_int to max int valuefloat fl = 3.0f;long lo = 4l;long long lolo = 5ll;double dou = 6.0;char* pChr = &chr;short* pSht = &sht;int* pIn = &in;float* pFl = &fl;long* pLo = &lo;long long* pLolo = &lolo;double* pDou = &dou;cout << "char类型指针及其算术运算:\t" << (void*)(pChr - 1) << '\t' << (void*)(pChr) << '\t' << (void*)(pChr + 1) << endl;cout << "short类型指针及其算术运算:\t" << pSht - 1 << '\t' << pSht << '\t' << pSht + 1 << endl;cout << "int类型指针及其算术运算:\t" << pIn - 1 << '\t' << pIn << '\t' << pIn + 1 << endl;cout << "float类型指针及其算术运算:\t" << pFl - 1 << '\t' << pFl << '\t' << pFl + 1 << endl;cout << "long类型指针及其算术运算:\t" << pLo - 1 << '\t' << pLo << '\t' << pLo + 1 << endl;cout << "longlong类型指针及其算术运算:\t" << pLolo - 1 << '\t' << pLolo << '\t' << pLolo + 1 << endl;cout << "double类型指针及其算术运算:\t" << pDou - 1 << '\t' << pDou << '\t' << pDou + 1 << endl;return 0;
}

实际上，由于指针退化，下面所说的各种类型的指针还可以指向对应类型的数组，但此处暂时认为其指向单一对象的指针。由于内存地址在计算机中用十六进制表示，注意十六进制与十进制算术运算的异同。

pChr的类型为char*，即pChr指向一个char类型的对象，而这个对象占1个字节，所以对它-1或者+1，指针只向前或者向后移动1个字节。

pSht的类型为short*，即pSht指向一个short类型的对象，而这个对象占2个字节，所以对它-1或者+1，指针只向前或者向后移动2个字节。

pIn的类型为int*，即pIn指向一个int类型的对象，而这个对象占4个字节，所以对它-1或者+1，指针只向前或者向后移动4个字节。

pFl的类型为float*，即pFl指向一个char类型的对象，而这个对象也占4个字节，所以对它-1或者+1，指针只向前或者向后移动4个字节。

pLo的类型为long*，即pLo指向一个long类型的对象，而这个对象也占4个字节，所以对它-1或者+1，指针只向前或者向后移动4个字节。

pLolo的类型为long long*，即pLolo指向一个long long类型的对象，而这个对象占8个字节，所以对它-1或者+1，指针只向前或者向后移动8个字节。

pDou的类型为double*，即pDou指向一个double类型的对象，而这个对象也占8个字节，所以对它-1或者+1，指针只向前或者向后移动8个字节。

二、指向对象数组的指针和该指针的加减算术运算
1、指向一维数组的指针和该指针的加减算术运算

#include<iostream>
#include <climits>
using namespace std;
int main(int argc, char *argv[])
{char chr[5] = { 'a', 'b', 'c', 'd', 'e' };short sht[5] = { 1, 2, 3, 4, 5 };int in[5] = { 1, 2, 3, 4, 5 };float fl[5] = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };long lo[5] = { 1l, 2l, 3l, 4l, 5l, };long long lolo[5] = { 1ll, 2ll, 3ll, 4ll, 5ll };double dou[5] = { 1.0, 2.0, 3.0, 4.0, 5.0 };char(*pChrArr)[5] = &chr; //声明并定义char(*)[5]类型指针，此指针指向该整个数组short(*pShtArr)[5] = &sht; //声明并定义short(*)[5]类型指针，此指针指向该整个数组int(*pInArr)[5] = &in; //声明并定义int(*)[5]类型指针，此指针指向该整个数组float(*pFlArr)[5] = &fl; //声明并定义float(*)[5]类型指针，此指针指向该整个数组long(*pLoArr)[5] = &lo; //声明并定义long(*)[5]类型指针，此指针指向该整个数组long long(*pLoloArr)[5] = &lolo; //声明并定义longlong(*)[5]类型指针，此指针指向该整个数组double(*pDouArr)[5] = &dou; //声明并定义double(*)[5]类型指针，此指针指向该整个数组cout << "char(*)[5]类型指针及其算术运算:\t\t" << (void*)(pChrArr - 1) << '\t' << (void*)(pChrArr) << '\t' << (void*)(pChrArr + 1) << endl;cout << "short(*)[5]类型指针及其算术运算:\t" << pShtArr - 1 << '\t' << pShtArr << '\t' << pShtArr + 1 << endl;cout << "int(*)[5]类型指针及其算术运算:\t\t" << pInArr - 1 << '\t' << pInArr << '\t' << pInArr + 1 << endl;cout << "float(*)[5]类型指针及其算术运算:\t" << pFlArr - 1 << '\t' << pFlArr << '\t' << pFlArr + 1 << endl;cout << "long(*)[5]类型指针及其算术运算:\t\t" << pLoArr - 1 << '\t' << pLoArr << '\t' << pLoArr + 1 << endl;cout << "longlong(*)[5]类型指针及其算术运算:\t" << pLoloArr - 1 << '\t' << pLoloArr << '\t' << pLoloArr + 1 << endl;cout << "double(*)[5]类型指针及其算术运算:\t" << pDouArr - 1 << '\t' << pDouArr << '\t' << pDouArr + 1 << endl;return 0;
}

指向一维数组的指针的声明及定义格式：typename (*pointer) [n] = &arrayname; 即指针pointer指向一个含有n个元素的typename类型的一维数组，该数组名称为arrayname。

指向一维数组的指针的类型为typename (*) [n]

pChrArr的类型为char(*)[5]，即 pChrArr指向一个包含5个char类型对象的数组，这个单一对象占1个字节，但是该数组占1*5个字节，所以对它-1或者+1，指针只向前或者向后移动5个字节。

pShtrArr的类型为short(*)[5]，即pShtArr指向一个包含5个short类型对象的数组，这个单一对象占2个字节，但是该数组占2*5个字节，所以对它-1或者+1，指针只向前或者向后移动10个字节。

pInArr的类型为int(*)[5]，即pInArr指向一个包含5个int类型对象的数组，这个单一对象占4个字节，但是该数组占4*5个字节，所以对它-1或者+1，指针只向前或者向后移动20个字节。

pFlrArr的类型为float(*)[5]，即pFlArr指向一个包含5个char类型对象的数组，这个单一对象也占4个字节，但是该数组占4*5个字节，所以对它-1或者+1，指针只向前或者向后移动20个字节。

pLoArr的类型为long(*)[5]，即pLoArr指向一个包含5个long类型对象的数组，这个单一对象占4个字节，但是该数组占4*5个字节，所以对它-1或者+1，指针只向前或者向后移动20个字节。

pLoloArr的类型为long long(*)[5]，即pLoloArr指向一个包含5个long long类型对象的数组，这个单一对象占8个字节，但是该数组占8*5个字节，所以对它-1或者+1，指针只向前或者向后移动40个字节。

pDouArr的类型为double(*)[5]，即pDouArr指向一个包含5个double类型对象的数组，这个单一对象占8个字节，但是该数组占8*5个字节，所以对它-1或者+1，指针只向前或者向后移动40个字节。

2、指向二维数组的指针和该指针的加减算术运算

#include<iostream>
#include <climits>
using namespace std;
int main(int argc, char *argv[])
{char chr[5][5] = { { 'a', 'b', 'c', 'd', 'e' },{ 'f', 'g', 'h', 'i', 'j' },{},{},{}} //未初始化的元素置空short sht[5][5] = { { 1, 2, 3, 4, 5 },{ 6, 7, 8, 9, 10 },{},{},{}}; //未初始化的元素置0int in[5][5] = { { 1, 2, 3, 4, 5 },{ 6, 7, 8, 9, 10 },{},{},{}}; //未初始化的元素置0float fl[5][5] = { { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f },{ 1.0f, 2.0f, 3.0f, 4.0f, 5.0f },{},{},{}}; //未初始化的元素置0long lo[5][5] = { { 1l, 2l, 3l, 4l, 5l, },{ 6l, 7l, 8l, 8l, 10l },{},{},{}}; //未初始化的元素置0long long lolo[5][5] = { { 1ll, 2ll, 3ll, 4ll, 5ll },{ 6ll, 7ll, 8ll, 9ll, 10ll },{},{},{}}; //未初始化的元素置0double dou[5][5] = { { 1.0, 2.0, 3.0, 4.0, 5.0 },{ 6.0, 7.0, 8.0, 9.0, 10.0 },{},{},{}}; //未初始化的元素置0cout << "chr[4][4]:\t" << chr[4][4]<< endl;cout << "sht[4][4]:\t" << sht[4][4] << endl;cout << "in[4][4]:\t" << in[4][4] << endl;cout << "fl[4][4]:\t" << fl[4][4] << endl;cout << "lo[4][4]:\t" << lo[4][4] << endl;cout << "lolo[4][4]:\t" << lolo[4][4] << endl;cout << "dou[4][4]:\t" << dou[4][4] << endl << endl;char(*pChrArr)[5][5] = &chr; //声明并定义char(*)[5][5]类型指针，此指针指向该整个二维数组short(*pShtArr)[5][5] = &sht; //声明并定义short(*)[5][5]类型指针，此指针指向该整个二维数组int(*pInArr)[5][5] = &in; //声明并定义int(*)[5][5]类型指针，此指针指向该整个二维数组float(*pFlArr)[5][5] = &fl; //声明并定义float(*)[5][5]类型指针，此指针指向该整个二维数组long(*pLoArr)[5][5] = &lo; //声明并定义long(*)[5][5]类型指针，此指针指向该整个二维数组long long(*pLoloArr)[5][5] = &lolo; //声明并定义longlong(*)[5][5]类型指针，此指针指向该整个二维数组double(*pDouArr)[5][5] = &dou; //声明并定义double(*)[5][5]类型指针，此指针指向该整个二维数组cout << "char(*)[5][5]类型指针及其算术运算:\t" << (void*)(pChrArr - 1) << '\t' << (void*)(pChrArr) << '\t' << (void*)(pChrArr + 1) << endl;cout << "short(*)[5][5]类型指针及其算术运算:\t" << pShtArr - 1 << '\t' << pShtArr << '\t' << pShtArr + 1 << endl;cout << "int(*)[5][5]类型指针及其算术运算:\t" << pInArr - 1 << '\t' << pInArr << '\t' << pInArr + 1 << endl;cout << "float(*)[5][5]类型指针及其算术运算:\t" << pFlArr - 1 << '\t' << pFlArr << '\t' << pFlArr + 1 << endl;cout << "long(*)[5][5]类型指针及其算术运算:\t" << pLoArr - 1 << '\t' << pLoArr << '\t' << pLoArr + 1 << endl;cout << "longlong(*)[5][5]类型指针及其算术运算:\t" << pLoloArr - 1 << '\t' << pLoloArr << '\t' << pLoloArr + 1 << endl;cout << "double(*)[5][5]类型指针及其算术运算:\t" << pDouArr - 1 << '\t' << pDouArr << '\t' << pDouArr + 1 << endl;return 0;
}

指向二维数组的指针的声明及定义格式：typename (*pointer) [i][j] = &arrayname; 即指针pointer指向一个含有i个一维数组，并且每个一维数组含有j个的typename类型对象，共i*j个元素。该数组名称为arrayname。

指向二维数组的指针的类型为typename (*)\ [i][j]

pChArr的类型为char(*)[5][5]，即 pChArr指向含有5个一维数组，并且每个一维数组都含有5个char类型单一对象（共25个元素），这个单一对象占1个字节，但是该二维数组占1*5*5个字节，所以对它-1或者+1，指针只向前或者向后移动25个字节。

pShtArr的类型为short(*)[5][5]，即pShtArr指向含有5个一维数组，并且每个一维数组都含有5个short类型单一对象（共25个元素），这个单一对象占2个字节，但是该二维数组占2*5*5个字节，所以对它-1或者+1，指针只向前或者向后移动50个字节。

pInArr的类型为int(*)[5][5]，即pInArr指向含有5个一维数组，并且每个一维数组都含有5个int类型单一对象（共25个元素），这个单一对象占4个字节，但是该二维数组占4*5*5个字节，所以对它-1或者+1，指针只向前或者向后移动100个字节。

pFlArr的类型为float(*)[5][5]，即pFlArr指向含有5个一维数组，并且每个一维数组都含有5个float类型单一对象（共25个元素），这个单一对象也占4个字节，但是该二维数组占4*5*5个字节，所以对它-1或者+1，指针只向前或者向后移动100个字节。

pLoArr的类型为long(*)[5][5]，即pLoArr指向含有5个一维数组，并且每个一维数组都含有5个long类型单一对象（共25个元素），这个单一对象占4个字节，但是该二维数组占4*5*5个字节，所以对它-1或者+1，指针只向前或者向后移动100个字节。

pLoloArr的类型为long long(*)[5][5]，即pLoloArr指向含有5个一维数组，并且每个一维数组都含有5个long long类型单一对象（共25个元素），这个单一对象占8个字节，但是该二维数组占8*5*5个字节，所以对它-1或者+1，指针只向前或者向后移动200个字节。

pDouArr的类型为double(*)[5][5]，即pDouArr指向含有5个一维数组，并且每个一维数组都含有5个double类型单一对象（共25个元素），这个单一对象占8个字节，但是该二维数组占8*5*5个字节，所以对它-1或者+1，指针只向前或者向后移动200个字节。

3、指向三维数组的指针和该指针的加减算术运算

#include<iostream>
#include <climits>
using namespace std;
int main(int argc, char *argv[])
{char chr[5][5][5] = {	{ { 'a', 'b', 'c', 'd', 'e' },{ 'f', 'g', 'h', 'i', 'j' },{},{},{} },{ {},{},{},{},{} },{ {},{},{},{},{} },{ {},{},{},{},{} },{ {},{},{},{},{} }}; //未初始化的元素置0short sht[5][5][5] = {	{ { 1, 2, 3, 4, 5 },{ 6, 7, 8, 9, 10 },{},{},{} },{ {},{},{},{},{} },{ {},{},{},{},{} },{ {},{},{},{},{} },{ {},{},{},{},{} }}; //未初始化的元素置0int in[5][5][5] = { { { 1, 2, 3, 4, 5 },{ 6, 7, 8, 9, 10 },{},{},{} },{ {},{},{},{},{} },{ {},{},{},{},{} },{ {},{},{},{},{} },{ {},{},{},{},{} }}; //未初始化的元素置0float fl[5][5][5] = {	{ { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f },{ 1.0f, 2.0f, 3.0f, 4.0f, 5.0f },{},{},{} },{ {},{},{},{},{} },{ {},{},{},{},{} },{ {},{},{},{},{} },{ {},{},{},{},{} }}; //未初始化的元素置0long lo[5][5][5] = {	{ { 1l, 2l, 3l, 4l, 5l, },{ 6l, 7l, 8l, 8l, 10l },{},{},{} },{ {},{},{},{},{} },{ {},{},{},{},{} },{ {},{},{},{},{} },{ {},{},{},{},{} }}; //未初始化的元素置0long long lolo[5][5][5] = { { { 1ll, 2ll, 3ll, 4ll, 5ll },{ 6ll, 7ll, 8ll, 9ll, 10ll },{},{},{} },{ {},{},{},{},{} },{ {},{},{},{},{} },{ {},{},{},{},{} },{ {},{},{},{},{} }}; //未初始化的元素置0double dou[5][5][5] = { { { 1.0, 2.0, 3.0, 4.0, 5.0 },{ 6.0, 7.0, 8.0, 9.0, 10.0 },{},{},{} },{ {}, {}, {}, {}, {} },{ {}, {}, {}, {}, {} },{ {}, {}, {}, {}, {} },{ {}, {}, {}, {}, {} }}; //未初始化的元素置0char(*pChrArr)[5][5][5] = &chr; //声明并定义char(*)[5][5]类型指针，此指针指向该整个二维数组short(*pShtArr)[5][5][5] = &sht; //声明并定义short(*)[5][5]类型指针，此指针指向该整个二维数组int(*pInArr)[5][5][5] = &in; //声明并定义int(*)[5][5]类型指针，此指针指向该整个二维数组float(*pFlArr)[5][5][5] = &fl; //声明并定义float(*)[5][5]类型指针，此指针指向该整个二维数组long(*pLoArr)[5][5][5] = &lo; //声明并定义long(*)[5][5]类型指针，此指针指向该整个二维数组long long(*pLoloArr)[5][5][5] = &lolo; //声明并定义longlong(*)[5][5]类型指针，此指针指向该整个二维数组double(*pDouArr)[5][5][5] = &dou; //声明并定义double(*)[5][5]类型指针，此指针指向该整个二维数组cout << "char(*)[5][5][5]类型指针及其算术运算:\t\t" << (void*)(pChrArr - 1) << '\t' << (void*)(pChrArr) << '\t' << (void*)(pChrArr + 1) << endl;cout << "short(*)[5][5][5]类型指针及其算术运算:\t\t" << pShtArr - 1 << '\t' << pShtArr << '\t' << pShtArr + 1 << endl;cout << "int(*)[5][5][5]类型指针及其算术运算:\t\t" << pInArr - 1 << '\t' << pInArr << '\t' << pInArr + 1 << endl;cout << "float(*)[5][5][5]类型指针及其算术运算:\t\t" << pFlArr - 1 << '\t' << pFlArr << '\t' << pFlArr + 1 << endl;cout << "long(*)[5][5][5]类型指针及其算术运算:\t\t" << pLoArr - 1 << '\t' << pLoArr << '\t' << pLoArr + 1 << endl;cout << "longlong(*)[5][5][5]类型指针及其算术运算:\t" << pLoloArr - 1 << '\t' << pLoloArr << '\t' << pLoloArr + 1 << endl;cout << "double(*)[5][5][5]类型指针及其算术运算:\t\t" << pDouArr - 1 << '\t' << pDouArr << '\t' << pDouArr + 1 << endl;return 0;
}

指向三维数组的指针的声明及定义格式：typename (*pointer)\ [i][j][k] = &arrayname; 即指针pointer指向一个含有i个二维数组，并且这i个二维数组每个都含有j个一维数组，并且这j个一维数组中每个都含有k个单一类型的的typename类型对象，共i*j*k个元素。该数组名称为arrayname。

指向三维数组的指针的类型为typename (*)\ [i][j][k]

pChrArr的类型为char(*)[5][5][5]，即 pChrArr指向含有5个二维数组，并且每个二维数组都含有5个一维数组，并且每个一维数组中都含有5个char类型单一对象，共125个元素，这个单一对象占1个字节，但是该三维数组占1*5*5*5个字节，所以对它-1或者+1，指针只向前或者向后移动125个字节。

pShtArr的类型为short(*)[5][5][5]，即pShtArr指向含有5个二维数组，并且每个二维数组都含有5个一维数组，并且每个一维数组中都含有5个short类型单一对象，共125个元素，这个单一对象占2个字节，但是该三维数组占2*5*5*5个字节，所以对它-1或者+1，指针只向前或者向后移动250个字节。

pInArr的类型为int(*)[5][5][5]，即pInArr指向含有5个二维数组，并且每个二维数组都含有5个一维数组，并且每个一维数组中都含有5个int类型单一对象，共125个元素，这个单一对象占4个字节，但是该三维数组占4*5*5*5个字节，所以对它-1或者+1，指针只向前或者向后移动500个字节。

pFlArr的类型为float(*)[5][5][5]，即pFlArr指向含有5个二维数组，并且每个二维数组都含有5个一维数组，并且每个一维数组中都含有5个float类型单一对象，共125个元素，这个单一对象占4个字节，但是该三维数组占4*5*5*5个字节，所以对它-1或者+1，指针只向前或者向后移动500个字节。

pLoArr的类型为long(*)[5][5][5]，即pLoArr指向含有5个二维数组，并且每个二维数组都含有5个一维数组，并且每个一维数组中都含有5个long类型单一对象，共125个元素，这个单一对象占4个字节，但是该三维数组占4*5*5*5个字节，所以对它-1或者+1，指针只向前或者向后移动500个字节。

pLoloArr的类型为long long(*)[5][5][5]，即pLoloArr指向含有5个二维数组，并且每个二维数组都含有5个一维数组，并且每个一维数组中都含有5个long long类型单一对象，共125个元素，这个单一对象占8个字节，但是该三维数组占8*5*5*5个字节，所以对它-1或者+1，指针只向前或者向后移动1000个字节。

pDouArr的类型为double(*)[5][5][5]，即pDouArr指向含有5个二维数组，并且每个二维数组都含有5个一维数组，并且每个一维数组中都含有5个double类型单一对象，共125个元素，这个单一对象占8个字节，但是该三维数组占8*5*5*5个字节，所以对它-1或者+1，指针只向前或者向后移动1000个字节。

4、指向n维数组的指针和该指针的加减算术运算

类推地，指向n维数组的指针的声明及定义格式：typename(*pointer) [a(0)][a(1)][a(2)]…[a(n)]（共有n个[]，每个[]中都要有数字） = &arrayname; 即指针pointer指向一个含有a(0)个n-1维数组，并且这a(0)个n-1维数组中每个都含有a(1)个n-2维数组，并且这a(1)个n-2维数组中每个都含有a(2)个n-3维数组…并且这a(n-1)个一维数组中每个都含有a(n)个单一类型的typename类型对象，共a(0)*a(1)*a(2)…*a(n)个元素。该数组名称为arrayname。

指向n维数组的指针的类型为typename(*)[a(0)][a(1)][a(2)]…[a(n)]

pTypenameArr的类型为typename(*)[a(0)][a(1)][a(2)]…[a(n)]，即 pTypenameArr指向一个含有a(0)个n-1维数组，并且这a(0)个n-1维数组中每个都含有a(1)个n-2维数组，并且这a(1)个n-2维数组中每个都含有a(2)个n-3维数组…并且这a(n-1)个一维数组中每个都含有typename类型单一对象，共a(0)*a(1)*a(2)…*a(n)个元素。这个单一对象占sizeof(typename)个字节，但是该n维数组占sizeof(typename)*a(0)*a(1)*a(2)…*a(n)个字节，所以对它-1或者+1，指针只向前或者向后移动sizeof(typename)*a(0)*a(1)*a(2)…*a(n)个字节。

参考
《C语言程序设计》（第3版）（谭浩强,清华大学出版社）
《C++程序设计教程》（第3版）（王珊珊，臧洌，张志航，机械工业出版社）
《C++ Primer Plus》（Six Edition）(Stephen Prata)
《C和指针》（Kenneth A. Reek)
广大的CSDN社友们的文章