通过和大家的讨论，受益匪浅。再次谢谢大家的热情。

天啊,一群强人...其实我觉得,数组和指针在本质上都差不多..返回的指针有时候可以当数组名字用,这个在于理解不一样.......如a(*p){//就是可以用p[]}当然在主调函数中作为参数的数组是有确定的位数得....

回34楼，你思维已经严重的形成定势了。
指针只是C++里面常用来表示数组的方式，但是，不是唯一的方式！
数组是抽象数据类型ADT的一种，实现他可以有很多方法。
数组下标的上下界只是数组这种ADT的元素之一，但不是必要元素，或者说，不是用来判定这个ADT是否是数组的特征依据。
具体点说，在函数的形参列表和返回类型出现的type*或者type**，你根本无法在不结合上下文的情况下判定是指针还是一、二维数组。
给你个提示，可以完全不用返回指针，你也可以用类去定义一个数组的ADT，这个ADT完全可以使用类方法（成员函数）来实现数组的全部功能。

[[italic] 本帖最后由 lf426 于 2008-1-11 11:43 编辑 [/italic]]

哎!~我不和你扯了，浪费我的时间!!
你要去用类加个operator []重载来封装也好,,,要干什么也好,,,,你自己慢慢去玩!!!!
        严重告诫你!多看点书.....什么《inside the C ++ object modle》 《C++程序设计陷阱》
《effitive C++》 《more effitive C++》 《C++必会必知》 《expectional C++style》 etc.....

我倒是劝戒你不要读死书，多分析实际问题，另外，别忘了学习数据结构和算法分析。

抽空乱写段代码，不完整的建立一个二维数组的类，实现二维数组的基本功能。目的不是说代码本身，而是希望初学者千万不要过多的形成思维定势。
在计算机语言领域，有且只有两种基本元素，数据和算法。这两个基本元素是不变的，演变的只是他们的关系。
所以，所谓二维数组，也仅仅就是ADT的一种，虽然在C++里面习惯性用指针返回，但是实际上的ADT模型是可以不跟指针返回有联系的。

//filename: arr2d.h

#ifndef ARR2D_H_
#define ARR2D_H_
#include <iostream>

class Arr2D
{
private:
    int xSize;
    int ySize;
    struct Coor
    {
        int x;
        int y;
        int v;
    };
    Coor* unit;
public:
    Arr2D();
    Arr2D(int x_size, int y_size);
    ~Arr2D();
    void showValue(int x_at, int y_at)const;
    int getValue(int x_at, int y_at)const;
    void setValue(int x_at, int y_at, int v_set_to);
};

#endif

//filename: arr2d.cpp

#include "arr2d.h"

Arr2D::Arr2D()
{
    xSize = 0;
    ySize = 0;
    Coor* temp = new Coor[0];
    unit = temp;
}

Arr2D::Arr2D(int x_size, int y_size)
{
    xSize = x_size;
    ySize = y_size;
    int dataSize = xSize * ySize;
    Coor* temp = new Coor[dataSize];
    for (int i = 0; i < xSize; i++){
        for (int j = 0; j < ySize; j++){
            int sn = ySize * i + j;
            temp[sn].v = 0;
            temp[sn].x = i;
            temp[sn].y = j;
        }
    }
    unit = temp;
}

Arr2D::~Arr2D()
{
    delete [] unit;
}

void Arr2D::showValue(int x_at, int y_at)const
{
    for (int i = 0; i < xSize; i++){
        for (int j = 0; j < ySize; j++){
            int sn = ySize * i + j;
            if ( unit[sn].x == x_at && unit[sn].y == y_at){
                std::cout << "unit[" << unit[sn].x << "," << unit[sn].y
                          << "] = " << unit[sn].v << std::endl;
            }
        }
    }
}

int Arr2D::getValue(int x_at, int y_at)const
{
    for (int i = 0; i < xSize; i++){
        for (int j = 0; j < ySize; j++){
            int sn = ySize * i + j;
            if ( unit[sn].x == x_at && unit[sn].y == y_at){
                return unit[sn].v;
            }
        }
    }
    return 0;
}

void Arr2D::setValue(int x_at, int y_at, int v_set_to)
{
    for (int i = 0; i < xSize; i++){
        for (int j = 0; j < ySize; j++){
            int sn = ySize * i + j;
            if ( unit[sn].x == x_at && unit[sn].y == y_at){
                unit[sn].v = v_set_to;
            }
        }
    }
}

//filename: main.cpp
//使用下面语句可创建 X_SIZE * Y_SIZE 的二维数组：
//Arr2D objName ( X_SIZE, Y_SIZE );
//使用下面成员函数将二维数组的x,y位置赋值为A;
//objName.setValue(x,y,A);
//使用下面成员函数可返回二维数组x,y处的值
//objName.getValue(x,y);
//使用下面成员函数可直接显示二维数组x,y处的值
//objName.showValue(x,y);

#include "arr2d.h"

int main(int argc, char* argv[])
{
    int const X_SIZE = 3;
    int const Y_SIZE = 4;
    Arr2D test ( X_SIZE, Y_SIZE );
    for (int i = 0; i < X_SIZE; i++){
        for(int j = 0; j < Y_SIZE; j++){
            test.setValue(i,j,100+Y_SIZE*i+j);
        }
    }
    test.setValue(1,1,200);
    test.setValue(2,2,300);

    for (int i = 0; i < X_SIZE; i++){
        for(int j = 0; j < Y_SIZE; j++){
            test.showValue(i,j);
        }
    }

    int test_get = test.getValue(2,2);
    std::cout << "test_get = " << test_get << std::endl;

    return 0;
}

两位都是大师，俺刚来。不过我觉得数组干嘛要用返回呢？直接在调用函数中声明，又不用重新分配空间。难道你声明一个数组就是用来返回呀，再说还不能返回呢，何必呢

形象点说，如果需要一张课程表，也就是就需要返回一个二维数组。
是给你一张课程表纸方便呢，还是给你一本书外加告诉你能在哪里找到你要的课程表的小纸条方便呢？
用一个对象表示一个二维数组难道不比用type**看起来更直观吗？OOP的目标不就是建立起更加形象的抽象模型吗？
我想说的就是，尽管狭义上说，函数是不能返回数组的，但是不要就定势思维觉得函数就一定不能返回数组。
把对数组的认识上升到ADT的模型是完全可以用类对象来作为返回值的。
当然我那个类写得很基础，或者严格来说是不完善甚至错误的，如果用我的类对象返回，为了不出错只能返回指针或者引用。
但是如果重载了operator=()等函数并采用深度复制，函数甚至可以直接返回类对象按值传递，也就是说，函数直接返回了二维数组。
所以，结论是C++中函数返回一个二维数组，从广义上来讲是完全可行的。

[[italic] 本帖最后由 lf426 于 2008-1-11 23:17 编辑 [/italic]]

二维数组的问题是直到C99的出现，允许声明变长数组才得到完满解决的，可惜VC一直没有对变长数组进行支持。所以如果你要用最基本的数据类型的话，还是用一维数组当二维来用好了，如果想写得优美些，就自己写数组模板吧

还真是学到不少东西。