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

news2025/1/23 15:09:31

预备知识
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 file
	int n_int = INT_MAX; // initialize n_int to max int value
	float 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 file
	int in = 2; // initialize n_int to max int value
	float 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 },{},{},{}}; //未初始化的元素置0
	int in[5][5] = { { 1, 2, 3, 4, 5 },{ 6, 7, 8, 9, 10 },{},{},{}}; //未初始化的元素置0
	float fl[5][5] = { { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f },{ 1.0f, 2.0f, 3.0f, 4.0f, 5.0f },{},{},{}}; //未初始化的元素置0
	long lo[5][5] = { { 1l, 2l, 3l, 4l, 5l, },{ 6l, 7l, 8l, 8l, 10l },{},{},{}}; //未初始化的元素置0
	long long lolo[5][5] = { { 1ll, 2ll, 3ll, 4ll, 5ll },{ 6ll, 7ll, 8ll, 9ll, 10ll },{},{},{}}; //未初始化的元素置0
	double dou[5][5] = { { 1.0, 2.0, 3.0, 4.0, 5.0 },{ 6.0, 7.0, 8.0, 9.0, 10.0 },{},{},{}}; //未初始化的元素置0

	cout << "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' },{},{},{} },
							{ {},{},{},{},{} },
							{ {},{},{},{},{} },
							{ {},{},{},{},{} },
							{ {},{},{},{},{} }
						 }; //未初始化的元素置0
	short sht[5][5][5] = {	
							{ { 1, 2, 3, 4, 5 },{ 6, 7, 8, 9, 10 },{},{},{} },
							{ {},{},{},{},{} },
							{ {},{},{},{},{} },
							{ {},{},{},{},{} },
							{ {},{},{},{},{} }
						  }; //未初始化的元素置0
	int in[5][5][5] = { 
						{ { 1, 2, 3, 4, 5 },{ 6, 7, 8, 9, 10 },{},{},{} },
						{ {},{},{},{},{} },
						{ {},{},{},{},{} },
						{ {},{},{},{},{} },
						{ {},{},{},{},{} }
					   }; //未初始化的元素置0
	float fl[5][5][5] = {	
							{ { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f },{ 1.0f, 2.0f, 3.0f, 4.0f, 5.0f },{},{},{} },
							{ {},{},{},{},{} },
							{ {},{},{},{},{} },
							{ {},{},{},{},{} },
							{ {},{},{},{},{} }
						 }; //未初始化的元素置0
	long lo[5][5][5] = {	
							{ { 1l, 2l, 3l, 4l, 5l, },{ 6l, 7l, 8l, 8l, 10l },{},{},{} },
							{ {},{},{},{},{} },
							{ {},{},{},{},{} },
							{ {},{},{},{},{} },
							{ {},{},{},{},{} }
						}; //未初始化的元素置0
	long long lolo[5][5][5] = { 
								{ { 1ll, 2ll, 3ll, 4ll, 5ll },{ 6ll, 7ll, 8ll, 9ll, 10ll },{},{},{} },
								{ {},{},{},{},{} },
								{ {},{},{},{},{} },
								{ {},{},{},{},{} },
								{ {},{},{},{},{} }
							   }; //未初始化的元素置0
	double dou[5][5][5] = { 
							{ { 1.0, 2.0, 3.0, 4.0, 5.0 },{ 6.0, 7.0, 8.0, 9.0, 10.0 },{},{},{} },
							{ {}, {}, {}, {}, {} },
							{ {}, {}, {}, {}, {} },
							{ {}, {}, {}, {}, {} },
							{ {}, {}, {}, {}, {} }
													}; //未初始化的元素置0

	char(*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社友们的文章

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/397035.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Spring Cloud学习笔记：基础知识

Spring Cloud学习笔记：基础知识

这是本人学习的总结&#xff0c;主要学习资料如下 马士兵教育 目录1、Spring Cloud 简介2、Eureka3、建立Spring Cloud项目3.1、启动Server3.1.1、dependency3.1.2、配置文件3.1.3、Server端启动代码3.2、启动Client3.2.1、dependency3.2.2、配置文件3.3.3、Client端启动代码3…
阅读更多...
Go之入门（特性、变量、常量、数据类型）

Go之入门（特性、变量、常量、数据类型）

一、Go语言特性 语法简单并发性。Go语言引入了协程goroutine&#xff0c;实现了并发编程内存分配。Go语言为了解决高并发下内存的分配和管理&#xff0c;选择了tcmalloc进行内存分配&#xff08;为了并发设计的高性能内存分配组件&#xff0c;使用cache为当前线程提供无锁分配…
阅读更多...
电脑自动重启是什么原因？详细解说

电脑自动重启是什么原因？详细解说

案例&#xff1a;电脑自动重启是什么原因&#xff1f; “一台用了一年的电脑&#xff0c;最近使用&#xff0c;每天都会一两次莫名其妙自动重启&#xff0c;看了电脑错误日志&#xff0c;看不懂什么意思&#xff0c;一直找不到答案。有没有高手知道怎么解决这个问题的。” 当…
阅读更多...
仿写简单IOC

仿写简单IOC

目录 TestController类: UserService类: 核心代码SpringIOC&#xff1a; Autowired和Component注解 SpringIOCTest 类 ​编辑 总结&#xff1a; TestController类: Component public class TestController {Autowiredprivate UserService userService;public void test…
阅读更多...
RocketMQ如何测试

RocketMQ如何测试

RocketMQ如何测试MQ简介RocketMQRocketMQ测试点MQ简介 MQ&#xff1a;Message Queue&#xff0c;即消息队列&#xff0c;是一种应用程序之间的消息通信&#xff0c;简单理解就是A服务不断的往队列里发布信息&#xff0c;另一服务B从队列中读取消息并执行处理&#xff0c;消息发…
阅读更多...
同步、异步ETL架构的比较

同步、异步ETL架构的比较

背景介绍&#xff1a; 数据的抽取&#xff0c;转换和加载 (ETL, Extract, Transform, Load) 是构建数据仓库过程中最复杂也是至 关重要的一个步骤&#xff0c;我们通常用两种办法来处理 ETL 流程: 一种是异步(Asynchronous) ETL 方式, 也称为文本文件(Flat file)方式。 另外…
阅读更多...
华为云平台架构名词解释

华为云平台架构名词解释

名词解释 网络设备 ISW&#xff08;外网接入交换机&#xff09;&#xff1a;出口交换机&#xff0c;常用于和外网建立静态/BGP路由互联 CSW &#xff08;内网接入交换机&#xff09;&#xff1a;专线接入&#xff08;用户内网骨干&#xff09;交换机&#xff0c;用户自有网络…
阅读更多...
一场以数字技术深度影响和改造传统实业的新风口，正在开启

一场以数字技术深度影响和改造传统实业的新风口，正在开启

当数字经济的浪潮开始上演&#xff0c;一场以数字技术深度影响和改造传统实业的新风口&#xff0c;正在开启。对于诸多在互联网时代看似业已走入死胡同的物种来讲&#xff0c;可以说是打开了新的天窗。对于金融科技来讲&#xff0c;同样如此。以往&#xff0c;谈及金融科技&…
阅读更多...
蓝桥杯-左移右移(2022国赛)

蓝桥杯-左移右移(2022国赛)

蓝桥杯-左移右移1、问题描述2、解题思路与代码实现2.1 方法一&#xff1a;使用LinkedList双向链表实现(50%)2.2 方法二&#xff1a;使用HashMap左右临界值实现(100%)1、问题描述 小蓝有一个长度为 N 的数组, 初始时从左到右依次是 1,2,3,…N 。 之后小蓝对这个数组进行了 M 次操…
阅读更多...
TX2配置RealSense D455相机SDK和ros驱动

TX2配置RealSense D455相机SDK和ros驱动

TX2配置RealSense D455相机SDK和ros驱动1 SDK安装2 RealSense-ros安装3 bug及解决3.1 realsense-viewer显示usb2.13.2 Could not found ddynamic_reconfigure折腾了两天终于把realsense的驱动装好了&#xff0c;尝试了命令安装&#xff0c;源码安装&#xff0c;前前后后搞了三遍…
阅读更多...
12.并发编程

12.并发编程

1.并发并发&#xff1a;逻辑流在时间时重叠构造并发程序&#xff1a;进程&#xff1a;每个逻辑控制流是一个进程&#xff0c;由内核调度和维护进程有独立的虚拟地址空间&#xff0c;想要通信&#xff0c;控制流必须使用某种显式的进程间通信机制(IPC)I/O多路复用&#xff1a;程…
阅读更多...
Linux - 第6节 - 动态库和静态库

Linux - 第6节 - 动态库和静态库

1.静态库与动态库概念 静态库&#xff08;.a&#xff09;&#xff1a;程序在编译链接的时候把库的代码拷贝到可执行文件中。程序运行的时候将不再需要静态库。动态库&#xff08;.so&#xff09;&#xff1a;程序在运行的时候才去链接动态库的代码&#xff0c;多个程序共享使用…
阅读更多...
【javaEE初阶】第三节.多线程 (进阶篇 ) 死锁

【javaEE初阶】第三节.多线程 (进阶篇 ) 死锁

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言一、"死锁"出现的典型场景二、产生 "死锁" 的必要条件 三、解决 "死锁" 问题的办法 总结前言 今天对于多线程进阶的学习&#…
阅读更多...
【MapGIS精品教程】007：MapGIS投影变换案例教程

【MapGIS精品教程】007：MapGIS投影变换案例教程

MapGIS投影变换，包括创建坐标系、定义投影、单点投影、类投影、批量投影。 文章目录 一、创建坐标系1. 创建高斯平面坐标系2. 创建阿尔伯斯投影二、定义投影三、投影变换1. 单点投影2. 类投影3. 批量投影一、创建坐标系 在MagGIS数据库中，有个空间参考系的文件夹，内置了常见…
阅读更多...
【tensorflow onnx】TensorFlow2导出ONNX及模型可视化教程

【tensorflow onnx】TensorFlow2导出ONNX及模型可视化教程

文章目录1 背景介绍2 实验环境3 tf2onnx工具介绍4 代码实操4.1 TensorFlow2与ONNX模型导出4.2 ONNX正确性验证4.3 TensorFlow2与ONNX的一致性检查4.4 多输入的情况4.5 设定输入/输出节点5 ONNX模型可视化6 ir_version和opset_version修改7 ONNX输入输出维度修改8 致谢原文来自于…
阅读更多...
【教学典型案例】18.开门小例子理解面向对象

【教学典型案例】18.开门小例子理解面向对象

目录一&#xff1a;背景介绍业务场景&#xff1a;业务分析&#xff1a;二&#xff1a;实现思路1、面向过程&#xff1a;2、面向对象&#xff08;抽象、封装、继承、多态&#xff09;3、面向对象&#xff08;抽象、封装、继承、多态、反射&#xff09;三&#xff1a;实现过程1、…
阅读更多...
如何在 Istio 中使用 SkyWalking 进行分布式追踪

如何在 Istio 中使用 SkyWalking 进行分布式追踪

在云原生应用中&#xff0c;一次请求往往需要经过一系列的 API 或后台服务处理才能完成&#xff0c;这些服务有些是并行的&#xff0c;有些是串行的&#xff0c;而且位于不同的平台或节点。那么如何确定一次调用的经过的服务路径和节点以帮助我们进行问题排查&#xff1f;这时候…
阅读更多...
二极管损坏的原因有哪些？

二极管损坏的原因有哪些？

大家好，我是记得诚。 最近项目上肖特基二极管出问题了，概率性损坏，二极管本来是一个很简单的器件，这次重新整理一下，供大家参考。 二极管损坏，个人总结有如下几种情况。 1、过压 在Ta=25℃下，超过二极管的最大反向电压VR，二极管可能会被击穿，导致损坏。 2、过流 …
阅读更多...
SpringBoot的基本概念和使用

SpringBoot的基本概念和使用

文章目录一、什么是SpringBoot二、Spring Boot优点三、Spring Boot项目创建四、Spring Boot 配置文件1. yml语法2.properties与yml关系3.多系统的配置五、Spring Boot日志文件1.日志对象2.日志级别日志级别的设置System.out.println VS 日志的两个致命缺点3.日志持久化4.更简单…
阅读更多...
[ 常用工具篇 ] windows安装phpStudy_v8.1_X64

[ 常用工具篇 ] windows安装phpStudy_v8.1_X64

&#x1f36c; 博主介绍 &#x1f468;‍&#x1f393; 博主介绍&#xff1a;大家好&#xff0c;我是 _PowerShell &#xff0c;很高兴认识大家~ ✨主攻领域&#xff1a;【渗透领域】【数据通信】 【通讯安全】 【web安全】【面试分析】 &#x1f389;点赞➕评论➕收藏 养成习…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023