[求助]C＋＋数组问题

emuch

[这个贴子最后由emuch在 2006/02/23 10:51pm 第 1 次编辑]

//////////////////////////////////////////////////////
&#35;include <iostream.h>
const int M=200;
void main()
{
double a[M][M], b[M][M];
double aa=0, bb=0;
for(int i=0; i<M; i++)
for(int j=0; j<M; j++)
{
a[j]=1.0;
b[j]=1.0;
aa+=a[j];
bb+=b[j];
}
cout<<"aa="<<aa<<",  bb="<<bb<<endl;
}
////////////////////////////////////////////////////////
M＝200，运行很正常，可以输出结果。当M＝300时就会出现运行错误。
是不是C语言中对数组大小有限制，怎么申请大数组呢？

anyone

你这种方法建的数组好象是存在STACK里, 大小有限制.
2维数组在C/C++里不是很好用.建议用一维数组代替, 可以用 NEW 建指针数组, 这样可以用大数组.
其实最好用VECTOR, 做动态时很方便, 而且从2维到3维也更自然一些

emuch

多谢大侠指点！
我在琢磨琢磨，有问题再请教，呵呵

emuch

//////////////////////////////////////////////////////
&#35;include <iostream.h>
const int M=500;
void main()
{
double *a, *b;
double aa=0, bb=0;
a=new double[M*M];
b=new double[M*M];
for(int i=0; i<M; i++)
for(int j=0; j<M; j++)
{
a[i+j*M]=1.0;
b[i+j*M]=1.0;
aa+=a[i+j*M];
bb+=b[i+j*M];
}
cout<<"aa="<<aa<<",  bb="<<bb<<endl;
delete []a;
delete []b;
}
///////////////////////////////////////////////////////
OK，用NEW建指针数组，运行通过，M=1000都没问题， ：）

emuch

////////////////////////////////////////////////////////
&#35;include <iostream.h>
&#35;include <vector>
using std::vector;
const int M=1000;
void main()
{
vector <double> a(M*M);
vector <double> b(M*M);
double aa=0, bb=0;
for(int i=0; i<M; i++)
for(int j=0; j<M; j++)
{
a[i+j*M]=1.0;
b[i+j*M]=1.0;
aa+=a[i+j*M];
bb+=b[i+j*M];
}
cout<<"aa="<<aa<<",  bb="<<bb<<endl;
}
////////////////////////////////////////////////////////////////
这样也可以，只是还不太清楚vector的用法，anyone大侠能具体讲一讲吗？ 或者推荐些资料也可以，多谢！

anyone

vector 是STL STANDARD TEMPLATE LIBRARY(标准模板库?)中的一个基本模板, 相当于改进的数组, 提供很多高级功能,以及数据检测/保护. 基本完全可以取代数组. 具体可以参见介绍STL 的书.

emuch

多谢anyone大侠的指点，又学了一招，呵呵
有问题会再来问的，

emuch

http://nothingnowhere.blogchina.com/4539351.html
c＋＋中如何动态分配二维数组
关键词： 二维数组                                          
&#35;include<iostream.h>
void main()
{
int **p;
int N,M,s=0;
cin>>N>>M;
p = new int*[N];
for(int i=0;i<N;i++) { p = new int[M];  }
for(int j=0;j<M;j++)
  for(int k=0;k<N;k++)
  {p[k][j]=s++; cout<<p[k][j]<<endl;}
}

icearcher

用vector的缺点是执行速度慢。要是不强调速度的话，推荐vector，因为不容易出错。
跑得最快的还是数组。
楼上的这么用也是可以的，但缺点是容易出错，并且分配和撤销内存时的执行速度太慢，但一旦用起来还是很快的。
多维数组是C++永远的痛啊！
还是Fortran的执行速度快。

curflow

推荐使用8楼的方法，我就是这么用的，还有4楼说M＝1000都没问题，好像要试试。我上次用1000*1000系统就告诉我不行，我的机器内存是1G的。

emuch

下面引用由curflow在 2006/06/18 09:02pm 发表的内容：
推荐使用8楼的方法，我就是这么用的，还有4楼说M＝1000都没问题，好像要试试。我上次用1000*1000系统就告诉我不行，我的机器内存是1G的。

嗯，8楼的方法不错，我现在也这样用。至于数组最大能达到多大，还不太清楚，不过4楼的程序应该可以运行的。

swimmingfish

数组最大能达到多大,是可以调的，也就是调整stack的大小。
在vc里可以在project -> setting 里调，有点记不住了。但肯定能调。
所以1000*1000用一位数组是可以的。

sonix

对于数值计算中的应用，最好用的应该是valarray类，它是专门用于数值的一个类，而且内置了一些函数，十分便于应用。不过，要想用二维的最好自己做个封装。[br][br][以下内容由 sonix 在 2006年07月06日 01:26am 时添加] [br]
&#35;pragma once
&#35;include <valarray>
using namespace std;
//二维数组类，用vararray封装完成
//动作类似变量
class matrix
{
//代理类，完成取行、取列操作，并辅助完成[][]
//动作类似指针
private:
class _proxy{
private:
double*_Myptr;
size_t_MySize;
size_t_MyInc;
public:
_proxy(size_t size=0, size_t inc=0, double* ptr=NULL){_MySize = size;_MyInc = inc;_Myptr = ptr;}
~_proxy(){_MySize = 0;_MyInc = 0;_Myptr = NULL;}
const double& operator[](size_t _Off) const{return *(_Myptr+_Off*_MyInc);}//未判断是否越界
double& operator[](size_t _Off){return *(_Myptr+_Off*_MyInc);}//未判断是否越界
double operator*(const _proxy _Right){
double _rst=0.0;
if( _MySize == _Right._MySize )
for( size_t i=0; i<_MySize; i++)
_rst += (*this)*_Right;
return _rst;
}
private:
//不允许对代理类赋值
void operator=(double _Val){};
};
//私有变量
private:
size_t _MyRow;
size_t _MyCol;
valarray<double> _MyData;
//接口函数
public:
//默认构造函数
matrix(size_t row=0, size_t col=0, double data = 0):_MyRow(row), _MyCol(col), _MyData(data, row*col){}
//拷贝构造函数
//matrix(const matrix<_Ty>& _Right):_MyRow(_Rigth.row()), _MyCol(_Right.col()), _MyData(_Right.data()){}
//析构函数
~matrix(){}
//=================================================================================================
const size_t row(void) const {return _MyRow;}
const size_t col(void) const {return _MyCol;}
const valarray<double>& data(void) const {return _MyData;}
_proxy getRow(size_t rowN) {return _proxy( col(), 1, &_MyData[col()*rowN] );}
_proxy getCol(size_t colN) {return _proxy( row(), col(), &_MyData[colN] );}
//=================================================================================================
//赋值运算符
matrix& operator=(const matrix& _Right)
{
if(&_Right != NULL){
_MyRow = _Right.row();_MyCol = _Right.col();
_MyData = _Right.data();
}
return *this;
}
matrix& operator=( const double& _Val){_MyData = _Val;return *this;}
//[]，配合_proxy类完成[][]
_proxy operator[](size_t rowN) {return getRow(rowN);}
//加法
matrix operator+(matrix& _Right)
{
if( row()==_Right.row() && col()==_Right.col() )
{
matrix _rst(*this);
_rst._MyData += _Right.data();
return _rst;
}
return matrix();
}
matrix& operator+(double _Right)
{
this->_MyData += _Right;
return *this;
}
//减法
matrix operator-(matrix& _Right)
{
if( row()==_Right.row() && col()==_Right.col() )
{
matrix _rst(*this);
_rst._MyData -= _Right.data();
return _rst;
}
return matrix();
}
matrix operator-(double _Right)
{
this->_MyData -= _Right;
return *this;
}
//乘法运算符
matrix operator*(matrix& _Right)
{
if( col() == _Right.row() )
{
matrix _rst( row(), _Right.col() );
for( size_t i=0; i<_rst.row(); i++ )
for( size_t j=0; j<_rst.col(); j++ )
_rst[j] = getRow(i)*_Right.getCol(j);
return _rst;
}
return matrix();
}
matrix operator*(double _Right)
{
matrix _rst(*this);
_rst._MyData *= _Right;
return _rst;
}
//输出运算符
friend ostream& operator <<(ostream& os, matrix& _Right);
};
//输出运算符
ostream& operator << (ostream& os, matrix& _Right)
{
os << "matrix: " << endl;
os << "row = " << _Right.row() << "\t" << "col = " << _Right.col() << endl;
for(size_t i=0; i<_Right.row(); i++)
{
for(size_t j=0; j<_Right.col(); j++)
os << _Right[j] << "\t";
os << endl;
}
return os;
}[br][br][以下内容由 sonix 在 2006年07月06日 01:29am 时添加] [br]

yebing2002

原来还可以这样啊。

emuch

多谢13楼！