问题 1
有以下定义
class A
{
public:
    //.......
private:
    A inside_object;
    //.......
};


这样的话 A对象的私有成员里会有一个A类型的对象，名叫inside_object
但是这个名为inside_object的私有成员自己也会有一个A的对象名为inside_object的私有成员 ~~~
然后循环往复  岂不是要耗光内存  ~~？~~~~
 ~~~额额额额  ~想不通吖~~~~谁明白给我讲讲呗  ~~

问题 2
class A
{
      //  ...
};

class B
{
private:
    A myAobj;
public:
     //......
};
就是如果类A没有写A()这样的不接受参数的构造函数，那么类B内 myAobj这样的声明没问题吧  ？对myAobj的初始化是不是只能放在B的构造函数里呢  ？~
那么 类外可以像A myAobj;这样声明对象么~？

问题 3……

class A
{
private:
    int a;
    //....
public:
    //....
    void fun(int num=a);
};

实际情况是函数fun需要参数num来做运算，这时可以用对象内私有成员a，也可以从外部传递参数。但是这样做编译不通过，说只能把a声明成静态成员。但是我不想这么做，应该怎么解决呢~？
还有  如果a被声明成一个函数指针，也就是说fun函数需要一个函数指针做参数（可以是一个算法公式之类的），这种情况下要怎么办呢？~

以上问题  求解决方法和简单实例代码~~~

[[it] 本帖最后由 dracovash 于 2009-7-31 18:43 编辑 [/it]]

我的本意：
我做了一个矩阵的数据结构。那个fun其实是一个查询函数，原型是这样的：
template <class T>
CEleObj <T> * rec <T>::get(UINT,UINT,miterator <T> * =recite);
最后一个参数提供迭代器接口。可以使用内部的迭代器，也可以从外部传入更加便利的迭代器。
向第三个问题所说，私有成员int a代表的是内部声明的迭代器对象，我需要随时改变迭代器对象里面的内容，所以我不可能声明成const常量类型。其次每个矩阵都有自己的内部迭代器，所以不能声明成static类型。我这个确实是指针，也确实没通过编译~~~~

恩恩   ~~你写的比较简单~~~~我写的很复杂  现在在做策划  做完才能开始写……现在就是遇到这几个问题了  ~

共享一下  ……
typedef unsigned short int UINT;

//迭代器方向
enum ITE_DIR  
{
    ITD_RIGHT,
    ITD_DOWN ,   
    ITD_LEFT ,     
    ITD_UP   
};

//矩阵扩充方向
enum AUG_DIR
{
    AUG_RIGHT,
    AUG_DOWN ,
    AUG_LEFT ,
    AUG_UP   
};

//最终类对象生成元素之一
enum REC_TYPE  
{
    RT_LIST  ,   
    RT_REC   ,   
    RT_BOARD ,  
    RT_CUBE   
};
//输出风格
enum PRINT_TYPE
{
    PRT_NORMAL ,//普通输出
    PRT_ADD //输出地址
};

template<typename>class CEleObj;//基础元素类
template<typename>class rec;//基础矩阵类
template<typename>class recboard;//基础矩阵板类
template<typename>class reccube;//基础矩阵块类
template<typename>class miterator;//迭代器
class POINT;//点类

template<typename T>
class DIRP
{
public:
    CEleObj<T> * POINT_UP;
    CEleObj<T> * POINT_DOWN;
    CEleObj<T> * POINT_RIGHT;
    CEleObj<T> * POINT_LEFT;
};


class POINT
{
public:
    UINT x,y;
    POINT(UINT _x,UINT _y):
    x(_x),y(_y){}
    ~POINT(){}

};
template<typename T>
class CEleObj
{
public:
    CEleObj(){}
    CEleObj(T & rele):ele(rele){}
    T get(){return ele;}
    void set(T & rele){ele=rele;}

    DIRP<T> DP;
private:
    T ele;
};

template<typename T>
class miterator
{
    CEleObj<T> * nowplace;//当前迭代指针
    CEleObj<T> * phead;//头指针
    POINT nowpoint;//指针当前坐标
    
    miterator(const CEleObj<T> *);
public:
    miterator(const rec<T> &);
    ~miterator(){}
    bool next(ITE_DIR);//迭代函数
    bool locate(UINT,UINT);//迭代器定位
    bool locate(POINT);
};

template<typename T>
class rec
{
    UINT recx,recy;
    CEleObj<T> * headele;
    miterator<T> * recite;
public:
    friend class miterator<T>;
    rec();
    rec(UINT,UINT);
    rec(const rec &);//拷贝构造函数
    ~rec();


    bool insert(UINT,UINT,const T &);//插入元素
    bool edit(UINT,UINT,const T &);
    bool edit(POINT,const T &);
    CEleObj<T> * get(UINT,UINT);//查询算法~
    CEleObj<T> * get(POINT);
    bool augment(rec<T> &,AUG_DIR);//扩充算法：直接对接
    bool delrec();//删除整个矩阵
    void print(PRINT_TYPE);//打印整个矩阵

    bool _locate(UINT,UINT);//内部迭代器重定位
    bool _locate(POINT);
    bool _locate();

    UINT getx(){return recx;}
    UINT gety(){return recy;}
};

[[it] 本帖最后由 dracovash 于 2009-7-31 22:46 编辑 [/it]]

同志们我都明白了  ~谢谢大家  ~分我只给第一个回答问题的了  ~呵呵   ~~~
C++学起来还是蛮有意思的  ~做点自己的东西出来感觉很棒   ~~加油加油~~