大神们，帮帮忙

#include <iostream.h>
template <class Type> Type sum(Type* array,int size){
	Type total=0;
	for(int i=0;i<size;i++)
	{
		total+=*(array+i);
	}
	cout<<"The first:";
	return total;
}
template <class Type> Type sum(Type* a1,Type* a2,int size){
	Type total=0;
	for(int i=0;i<size;i++)
	{
		total+=a1[i]+a2[i];
	}
	cout<<"The second:";
	return total;
}
void main(){
	int a1[10],a2[8];
	float af[10];
	for(int i=0;i<10;i++){
		a1[i]=i;
		a2[i]=i;
		af[i]=i;
	}
	cout<<sum(a1,10)<<endl;
	cout<<sum(af,10)<<endl;
	cout<<sum(a1,a2,8)<<endl;
}

！ 为什么a2在赋值是不会发生溢出？还有就是a1和af数组内值相加和不同?求大神指导啊

33 个解决方案

#1

for(int i=0;i<10;i++)
a2[声明只有8个元素 你往里面装了10个 没有a[8],a[9],

#2

我也纳闷啊

引用 1 楼 modyaj 的回复:

for(int i=0;i<10;i++)
a2[声明只有8个元素 你往里面装了10个 没有a[8],a[9],

为什么赋值不会发生错误呢

#3

哦 还有第二问  a1和af数组内值相加和 有什么不同吗？

#4

引用 3 楼 modyaj 的回复:

哦 还有第二问  a1和af数组内值相加和 有什么不同吗？

运行出的结果不同

#5

引用 2 楼 BikeyTang 的回复:

我也纳闷啊

Quote: 引用 1 楼 modyaj 的回复:

for(int i=0;i<10;i++)
a2[声明只有8个元素 你往里面装了10个 没有a[8],a[9],

为什么赋值不会发生错误呢

我也纳闷 应该是错误已经是发生了的 只是还没有抛出来 

#6

引用 4 楼 BikeyTang 的回复:

Quote: 引用 3 楼 modyaj 的回复:

哦 还有第二问  a1和af数组内值相加和 有什么不同吗？

运行出的结果不同

cout<<sum(a1,10)<<endl;
 cout<<sum(af,10)<<endl;
----------------------
不都是45吗？

#7

a2[i]=i;只有8个单元，而循环了10次
af为float类型，float类型计算结果可能会有残余误差

#8

a1的结果61，af的结果是45

引用 7 楼 worldy 的回复:

a2[i]=i;只有8个单元，而循环了10次
af为float类型，float类型计算结果可能会有残余误差

#9

引用 6 楼 modyaj 的回复:

Quote: 引用 4 楼 BikeyTang 的回复:

Quote: 引用 3 楼 modyaj 的回复:

哦 还有第二问  a1和af数组内值相加和 有什么不同吗？

运行出的结果不同

cout<<sum(a1,10)<<endl;
 cout<<sum(af,10)<<endl;
----------------------
不都是45吗？

不一样。

#10

引用 8 楼 BikeyTang 的回复:

a1的结果61，af的结果是45

Quote: 引用 7 楼 worldy 的回复:

a2[i]=i;只有8个单元，而循环了10次
af为float类型，float类型计算结果可能会有残余误差

61怎么来的 ？

#11

不清楚啊，我只发现刚开始相加的时候它是+8然后+9，才+2.对此我也很纳闷，才来这问问大神们的

#12

引用 2 楼 BikeyTang 的回复:

我也纳闷啊

Quote: 引用 1 楼 modyaj 的回复:

for(int i=0;i<10;i++)
a2[声明只有8个元素 你往里面装了10个 没有a[8],a[9],

为什么赋值不会发生错误呢

为什么编译器一定会报错呢？只要访问的还是有效空间一般都是没问题的，因为C/C++的编译器一般不会主动对数组的下标做边界检查。

一般溢出后都会覆盖掉其他变量的值，你检查看看a1、af看看有没有被覆盖，单步看看。也可能覆盖了其他无效的地址，总之报不报错很难说。

#13

引用 12 楼 Adol1111 的回复:

Quote: 引用 2 楼 BikeyTang 的回复:

我也纳闷啊

Quote: 引用 1 楼 modyaj 的回复:

for(int i=0;i<10;i++)
a2[声明只有8个元素 你往里面装了10个 没有a[8],a[9],

为什么赋值不会发生错误呢

为什么编译器一定会报错呢？只要访问的还是有效空间一般都是没问题的，因为C/C++的编译器一般不会主动对数组的下标做边界检查。

一般溢出后都会覆盖掉其他变量的值，你检查看看a1、af看看有没有被覆盖，单步看看。也可能覆盖了其他无效的地址，总之报不报错很难说。

你这解释的有道理，但覆盖为什么是把a1的a1[0]和a1[1]给覆盖，而不是覆盖a2本身的??

#14

61其实很正常的，这就说明a1被a2覆盖了呗。
正常情况下 0+1+2+……+9 = 45没问题吧。
如果a2溢出，那么就会覆盖a1的值，一般是从起始位置覆盖（跟栈的特性、声明的顺序有关）。所以a[0]、a[1]被覆盖了，那么a2[8]=8，a2[9]=9，其实执行的都是a1[0]=8，a1[9]=9;
所以结果就是 8+9+2+3+……+9 = 61

#15

c对数组越界不报错的，需要程序员自己检查
你测试下动态申请内存

#16

引用 14 楼 Adol1111 的回复:

61其实很正常的，这就说明a1被a2覆盖了呗。
正常情况下 0+1+2+……+9 = 45没问题吧。
如果a2溢出，那么就会覆盖a1的值，一般是从起始位置覆盖（跟栈的特性、声明的顺序有关）。所以a[0]、a[1]被覆盖了，那么a2[8]=8，a2[9]=9，其实执行的都是a1[0]=8，a1[9]=9;
所以结果就是 8+9+2+3+……+9 = 61

请问覆盖过程有规则没还是随机覆盖?

#17

引用 13 楼 BikeyTang 的回复:

Quote: 引用 12 楼 Adol1111 的回复:

Quote: 引用 2 楼 BikeyTang 的回复:

我也纳闷啊

Quote: 引用 1 楼 modyaj 的回复:

for(int i=0;i<10;i++)
a2[声明只有8个元素 你往里面装了10个 没有a[8],a[9],

为什么赋值不会发生错误呢

为什么编译器一定会报错呢？只要访问的还是有效空间一般都是没问题的，因为C/C++的编译器一般不会主动对数组的下标做边界检查。

一般溢出后都会覆盖掉其他变量的值，你检查看看a1、af看看有没有被覆盖，单步看看。也可能覆盖了其他无效的地址，总之报不报错很难说。

你这解释的有道理，但覆盖为什么是把a1的a1[0]和a1[1]给覆盖，而不是覆盖a2本身的??

因为地址是连续的啊，栈上申请的变量又是反过来的。栈的特性是后进先出，是往栈顶上插入的。然后数组内部是正常顺序，结果画出来的地址就是这样的。

#18

你可以打印一下a1、a2的地址就知道了。

#19

引用 14 楼 Adol1111 的回复:

如果a2溢出，那么就会覆盖a1的值，一般是从起始位置覆盖（跟栈的特性、声明的顺序有关）。所以结果就是 

要是我吧a2声明在前，就覆盖a2吗？

#20

引用 19 楼 BikeyTang 的回复:

Quote: 引用 14 楼 Adol1111 的回复:

如果a2溢出，那么就会覆盖a1的值，一般是从起始位置覆盖（跟栈的特性、声明的顺序有关）。所以结果就是 

要是我吧a2声明在前，就覆盖a2吗？

自己打印一下数组的地址就知道了，溢出了也不会覆盖本身的。地址是连续的，而且不会回头。如果位置调换一下，覆盖的就是其他的内容了。如果覆盖的内容不是你定义的变量的地址，那就更难说了，说不定会直接报错。

#21

引用 20 楼 Adol1111 的回复:

Quote: 引用 19 楼 BikeyTang 的回复:

Quote: 引用 14 楼 Adol1111 的回复:

如果a2溢出，那么就会覆盖a1的值，一般是从起始位置覆盖（跟栈的特性、声明的顺序有关）。所以结果就是 

要是我吧a2声明在前，就覆盖a2吗？

自己打印一下数组的地址就知道了，溢出了也不会覆盖本身的。地址是连续的，而且不会回头。如果位置调换一下，覆盖的就是其他的内容了。如果覆盖的内容不是你定义的变量的地址，那就更难说了，说不定会直接报错。

嗯，没有覆盖本身，而且程序运行到最后报异常了

#22

引用 17 楼 Adol1111 的回复:

Quote: 引用 13 楼 BikeyTang 的回复:

Quote: 引用 12 楼 Adol1111 的回复:

Quote: 引用 2 楼 BikeyTang 的回复:

我也纳闷啊

Quote: 引用 1 楼 modyaj 的回复:

然后数组内部是正常顺序，结果画出来的地址就是这样的。

图片看不到，能再发次么？

#23

现在可以了看到了

#24

我写的那个模型好像有点问题，具体的地址你自己打印一下就知道了。

#25

打印的地址
谢谢Adol1111 ，这个问题基本没问题了

#26

引用 14 楼 Adol1111 的回复:

61其实很正常的，这就说明a1被a2覆盖了呗。
正常情况下 0+1+2+……+9 = 45没问题吧。
如果a2溢出，那么就会覆盖a1的值，一般是从起始位置覆盖（跟栈的特性、声明的顺序有关）。所以a[0]、a[1]被覆盖了，那么a2[8]=8，a2[9]=9，其实执行的都是a1[0]=8，a1[9]=9;
所以结果就是 8+9+2+3+……+9 = 61

突然发现这里的a1[0]=8，a1[9]=9;是我写错了...怪不得你会问是随机的。应该是a1[1]=9

#27

引用 13 楼 BikeyTang 的回复:

Quote: 引用 12 楼 Adol1111 的回复:

Quote: 引用 2 楼 BikeyTang 的回复:

我也纳闷啊

Quote: 引用 1 楼 modyaj 的回复:

for(int i=0;i<10;i++)
a2[声明只有8个元素 你往里面装了10个 没有a[8],a[9],

为什么赋值不会发生错误呢

为什么编译器一定会报错呢？只要访问的还是有效空间一般都是没问题的，因为C/C++的编译器一般不会主动对数组的下标做边界检查。

一般溢出后都会覆盖掉其他变量的值，你检查看看a1、af看看有没有被覆盖，单步看看。也可能覆盖了其他无效的地址，总之报不报错很难说。

你这解释的有道理，但覆盖为什么是把a1的a1[0]和a1[1]给覆盖，而不是覆盖a2本身的??

函数中的变量是压栈的，即先声明的变量地址比后声明的大（先入栈），因此a2超出范围的部分覆盖了a1的变量值，即8、9覆盖了0，1

#28

你好像学过模板了是吧！！

#29

c对数组越界不报错的，需要程序员自己检查
你测试下动态申请内存  SF

#30

引用 29 楼 fa20ng06 的回复:

c对数组越界不报错的，需要程序员自己检查
你测试下动态申请内存  SF

嗯

#31

引用 30 楼 yanxk888 的回复:

Quote: 引用 29 楼 fa20ng06 的回复:

c对数组越界不报错的，需要程序员自己检查
你测试下动态申请内存  SF

嗯

#32

不懂帮顶，顺便拿可用分十分~~

#33

引用 26 楼 Adol1111 的回复:

Quote: 引用 14 楼 Adol1111 的回复:

61其实很正常的，这就说明a1被a2覆盖了呗。
正常情况下 0+1+2+……+9 = 45没问题吧。
如果a2溢出，那么就会覆盖a1的值，一般是从起始位置覆盖（跟栈的特性、声明的顺序有关）。所以a[0]、a[1]被覆盖了，那么a2[8]=8，a2[9]=9，其实执行的都是a1[0]=8，a1[9]=9;
所以结果就是 8+9+2+3+……+9 = 61

突然发现这里的a1[0]=8，a1[9]=9;是我写错了...怪不得你会问是随机的。应该是a1[1]=9

引用 11 楼 BikeyTang 的回复:

不清楚啊，我只发现刚开始相加的时候它是+8然后+9，才+2.对此我也很纳闷，才来这问问大神们的

值被溢出的数组赋值覆盖了