小甲鱼-C++ 10 指针和数组

①指针和数组

1、数组的名字其实也是一个指针（指向数组的基地址，就是第一个元素的地址）

--- int *ptr1 = &myArray[0];

--- int *ptr2 = myArray; 

2、访问其他元素: ptr1++;

注意以上不是简单的对地址值进行+1处理,它是按照指向的数组的数据类型来递增的,也就是+sizeof(int)

#include <iostream>
 
using namespace std;
 
int main()
{
	const unsigned short ITEMS = 5;
 
	int intArray[ITEMS] = {1, 2, 3, 4, 5};
	char charArray[ITEMS] = {'F', 'i', 's', 'h', 'c'};
 
	int *intPtr = intArray;
	char *charPtr = charArray;
 
	cout << "整型数组输出: " << endl;
	for (int i = 0; i < ITEMS; i++)
	{
		cout << *intPtr << " at " << reinterpret_cast<unsigned long>(intPtr) << endl;
		intPtr++;
	}
 
	cout << "字符型数组输出: " << endl;
	for (int j = 0; j < ITEMS; j++)
	{
		cout << *charPtr << " at " << reinterpret_cast<unsigned long>(charPtr) << endl;
		charPtr++;
	}
 
	return 0;
}

对于函数 reinterpret_cast 理解:

C++中的reinterpret_cast主要是将数据从一种类型的转换为另一种类型。所谓“通常为操作数的位模式提供较低层的重新解释”也就是说将数据以二进制存在形式的重新解释。

同时C++中提供了4种新的强制类型转换形式(没怎么理解)：

const_cast(expression)

dynamic_cast(expression)

reinterpret_cast(expression)

static_cast(expression)

3，运行结果

整型数组输出: 
1 at 140732487977152
2 at 140732487977156
3 at 140732487977160
4 at 140732487977164
5 at 140732487977168
字符型数组输出: 
F at 140732487977187
i at 140732487977188
s at 140732487977189
h at 140732487977190
c at 140732487977191

4、思考:

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

int *ptr = Array;

则

* ptr + 1;

*(ptr + 1);

两者有何区别?

首先数组定义时就具有迷惑性，输出都是为2，但是两者意义不同

第一条语句执行顺序是（*ptr）+1，第二条语句的执行顺序是*（ptr+1），因此结果明显不一样

下图是验证结果：

#include <iostream>
  
int main()
{
        int Array[5] = {1,4,6,2,9};
        int *ptr = Array;

        std::cout << "*ptr+1: " << *ptr+1 <<std::endl;
        std::cout << "*(ptr+1): " << *(ptr+1) << std::endl;

        return 0;
}

运行结果：

*ptr+1: 2
*(ptr+1): 4

②数组和指针的应用举例：

1、重载

#include <iostream>
 
using namespace std;
 
//函数的重载
 
void print(int *pBegin, int *pEnd)
{
	while (pBegin != pEnd)
	{
		cout << *pBegin << endl;
		++pBegin;
	}
}
 
void print(char *pBegin, char *pEnd)
{
	while (pBegin != pEnd)
	{
		cout << *pBegin << endl;
		++pBegin;
	}
 
}
 
int main()
{
	const unsigned short ITEMS = 5;
	int num[ITEMS] = {0, 1, 2, 3, 4};
	char name[ITEMS] = {'F', 'i', 's', 'h', 'c'};
 
	print(num, num+ITEMS);
	cout << endl;
 
	print(name, name+ITEMS);
	cout << endl;
 
 
	return 0;
 
}

运行结果

0
1
2
3
4

F
i
s
h
c

 

2、泛型程序设计

在函数重载时，当每次设计到一种数据类型时，就得重新定义一个函数，这样很麻烦！

#include <iostream>
 
using namespace std;
 
template <typename elemType>
void print(elemType *pBegin, elemType *pEnd)
{
	while (pBegin != pEnd)
	{
		cout << *pBegin << endl;
		++pBegin;
	}
}
 
int main()
{
	const unsigned short ITEMS = 5;
	int num[ITEMS] = {0, 1, 2, 3, 4};
	char name[ITEMS] = {'F', 'i', 's', 'h', 'c'};
 
	print(num, num+ITEMS);
	cout << endl;
 
	print(name, name+ITEMS);
	cout << endl;
 
	return 0;
}

运行结果

0
1
2
3
4

F
i
s
h
c