数组和指针效率比较

[muhudai]

静态数组与动态数组，为什么运行时差别那么大，前者的速度是后者的约2倍（对于附件中的代码，我用的是C/C++，编译器为VC6，Release版本；试过其它编译器，情况类似）？前者是数组，物理地址连续；后者是指针，物理地址不连续导致寻址的速度存在差异？难道我要看看编译原理的书，才能明白其中的道理？

(1)

#include <iostream>
#include <fstream>
#include <iomanip>
#include <cmath>
#include <ctime>

using namespace std;

const int MAX_SOL = 10000000;
const int MAX_LOOP = 10;

const double gAlfa = 0.92;
const double gSmall = 1.0E-30;

double bb[MAX_SOL], bw[MAX_SOL], bs[MAX_SOL], bp[MAX_SOL], bn[MAX_SOL], be[MAX_SOL], bt[MAX_SOL];
//double *bb, *bw, *bs, *bp, *bn, *be, *bt;

void new_sol();

void delete_sol();

void sol(int );

void main()
{
    ofstream ofilout( "output.dat" );
	if (! ofilout) {
		cerr << "error: unable to open input file: "
			<< "output.dat" << endl;
		exit(0);
	}
	
	new_sol();
	
	clock_t t_start = clock();
    
    for ( int i = 0; i < MAX_LOOP; i++)
    {
		sol(i);
    }
    
	clock_t t_finish = clock();
	
	delete_sol();
	
	ofilout	<< setiosflags(ios::fixed) << setprecision(10);
	ofilout << " Program takes CPU time " 
		<< static_cast<double>(t_finish - t_start) / CLOCKS_PER_SEC
		<< " seconds." << endl;
	ofilout.close();
}

void new_sol()
{
	/*
	bb = new double[MAX_SOL];
	bw = new double[MAX_SOL];
	bs = new double[MAX_SOL];
	bp = new double[MAX_SOL];
	bn = new double[MAX_SOL];
	be = new double[MAX_SOL];
	bt = new double[MAX_SOL];
	
	for ( int i = 0; i < MAX_SOL; i++ )
	{
		bb[i] = 0.0;
		bw[i] = 0.0;
		bs[i] = 0.0;
		bp[i] = 0.0;
		bn[i] = 0.0;
		be[i] = 0.0;
		bt[i] = 0.0;
	}
	*/
}

void delete_sol()
{
	/*
	delete[] bb;
	delete[] bw;
	delete[] bs;
	delete[] bp;
	delete[] bn;
	delete[] be;
	delete[] bt;
	*/
}

void sol(int times)
{
	double temp, p1, p2, p3;
	
	double temp_times = pow(times, 1.0 / MAX_LOOP);
	
	for ( int k = 1; k < MAX_SOL; k++ )
	{
        temp = temp_times + pow(k, 1.0 / MAX_SOL);
		bb[k] = - temp / ( 1. + gAlfa * ( bn[k] + be[k] ) );
		bw[k] = - temp / ( 1. + gAlfa * ( bn[k] + bt[k] ) );
		bs[k] = - temp / ( 1. + gAlfa * ( be[k] + bt[k] ) );
		p1 = gAlfa * ( bb[k] * bn[k] + bw[k] * bn[k] );
		p2 = gAlfa * ( bb[k] * be[k] + bs[k] * be[k] );
		p3 = gAlfa * ( bw[k] * bt[k] + bs[k] * bt[k] );
		bp[k] = 1. / ( temp + p1 + p2 + p3 - bb[k] * bt[k]
			- bw[k] * be[k] - bs[k] * bn[k] + gSmall );
		bn[k] = ( - temp - p1 ) * bp[k];
		be[k] = ( - temp - p2 ) * bp[k];
		bt[k] = ( - temp - p3 ) * bp[k];
	}
}



(2)

#include <iostream>
#include <fstream>
#include <iomanip>
#include <cmath>
#include <ctime>

using namespace std;

const int MAX_SOL = 10000000;
const int MAX_LOOP = 10;

const double gAlfa = 0.92;
const double gSmall = 1.0E-30;

//double bb[MAX_SOL], bw[MAX_SOL], bs[MAX_SOL], bp[MAX_SOL], bn[MAX_SOL], be[MAX_SOL], bt[MAX_SOL];
double *bb, *bw, *bs, *bp, *bn, *be, *bt;

void new_sol();

void delete_sol();

void sol(int );

void main()
{
    ofstream ofilout( "output.dat" );
	if (! ofilout) {
		cerr << "error: unable to open input file: "
			<< "output.dat" << endl;
		exit(0);
	}
	
	new_sol();
	
	clock_t t_start = clock();
    
    for ( int i = 0; i < MAX_LOOP; i++)
    {
		sol(i);
    }
    
	clock_t t_finish = clock();
	
	delete_sol();
	
	ofilout	<< setiosflags(ios::fixed) << setprecision(10);
	ofilout << " Program takes CPU time " 
		<< static_cast<double>(t_finish - t_start) / CLOCKS_PER_SEC
		<< " seconds." << endl;
	ofilout.close();
}

void new_sol()
{
	bb = new double[MAX_SOL];
	bw = new double[MAX_SOL];
	bs = new double[MAX_SOL];
	bp = new double[MAX_SOL];
	bn = new double[MAX_SOL];
	be = new double[MAX_SOL];
	bt = new double[MAX_SOL];
	
	for ( int i = 0; i < MAX_SOL; i++ )
	{
		bb[i] = 0.0;
		bw[i] = 0.0;
		bs[i] = 0.0;
		bp[i] = 0.0;
		bn[i] = 0.0;
		be[i] = 0.0;
		bt[i] = 0.0;
	}
}

void delete_sol()
{
	delete[] bb;
	delete[] bw;
	delete[] bs;
	delete[] bp;
	delete[] bn;
	delete[] be;
	delete[] bt;
}

void sol(int times)
{
	double temp, p1, p2, p3;
	
	double temp_times = pow(times, 1.0 / MAX_LOOP);
	
	for ( int k = 1; k < MAX_SOL; k++ )
	{
        temp = temp_times + pow(k, 1.0 / MAX_SOL);
		bb[k] = - temp / ( 1. + gAlfa * ( bn[k] + be[k] ) );
		bw[k] = - temp / ( 1. + gAlfa * ( bn[k] + bt[k] ) );
		bs[k] = - temp / ( 1. + gAlfa * ( be[k] + bt[k] ) );
		p1 = gAlfa * ( bb[k] * bn[k] + bw[k] * bn[k] );
		p2 = gAlfa * ( bb[k] * be[k] + bs[k] * be[k] );
		p3 = gAlfa * ( bw[k] * bt[k] + bs[k] * bt[k] );
		bp[k] = 1. / ( temp + p1 + p2 + p3 - bb[k] * bt[k]
			- bw[k] * be[k] - bs[k] * bn[k] + gSmall );
		bn[k] = ( - temp - p1 ) * bp[k];
		be[k] = ( - temp - p2 ) * bp[k];
		bt[k] = ( - temp - p3 ) * bp[k];
	}
}

[muhudai]

时钟放在了循环的前后，因此不用考虑指针初始化的时间。。

[猫已经找不回了]

具体差距怎么计算就不知道了。但是动态的肯定要运行地慢些吧。很多时候不连续的地址处理起来肯定不如连续的效率高。

[帅得不敢出门]

动态申请的不保证是连续的空间.
也要考虑物理内存换入换出的问题.

[muhudai]

但是我的程序中动态指针初始化时，是用数组赋值的，所以这里指针的地址也是连续的

[luowin]

你说是直接寻址快（静态数组，在栈中分配--物理地址连续），还是间接寻址快（动态数组，堆中分配--逻辑地址连续）

[就呆在云上]

因此动态的有两倍的代码执行量
给你一个示例程序：

int main() {
	int a[10];
	int *b = new int[10];
	a[2] = 10;
	b[2] = 10;
	delete []b;
}

看汇编就ok了：

	
	a[2] = 10;
004113E7  mov         dword ptr [ebp-24h],0Ah 
	b[2] = 10;
004113EE  mov         eax,dword ptr [b] 
004113F1  mov         dword ptr [eax+8],0Ah 

差不多两倍了

[pengzhixi]

本身栈的访问速度比堆的访问速度应该要快些

[huxuanhui]

学习

[lann64]

没那么大差距吧。
用debug试了下，18.515s和20.171s
用release试， 15.734s和19.656s