用vector<CStringArray>会报错；数组(一维、二维、三维)的动态申请及用vector的表示方法

超、凢脫俗 2022-05-14 07:53 228阅读 0赞

=================用vector<CStringArray>会报错=========

CStringArray对象不能拷贝.  
而vector里面放的元素需要能够拷贝,所以编译错误.

因为基类CObject禁止对象拷贝，导致所有CObject派生累禁止拷贝

C/C++ code

// Disable the copy constructor and assignment by default so you will get
     //   compiler errors instead of unexpected behaviour if you pass objects
     //   by value or assign objects.
     protected:
     CObject();
     private:
     CObject(const CObject& objectSrc);              // no implementation
     void operator=(const CObject& objectSrc);       // no implementation

我们看到（引自：[http://blog.csdn.net/panjean/article/details/5989832][http_blog.csdn.net_panjean_article_details_5989832]）

1：CObject类的构造函数都不是public类型，因此我们没能直接去定义一个CObject类型的对象，而必须要用CObject类的派生类去定义定义个对象。

2：为什么CObject();是protected类型而不是private类型呢？

这是因为，CObject类的派生类在定义对象时，只能调用CObject的public类型或protected类型的构造函数，而不能CObject类型的构造函数。

看MFC源代码：

// CObject  
\_AFX\_INLINE CObject::CObject()  
\{ \}  
\_AFX\_INLINE CObject::~CObject()  
\{ \}

3：

private:  
CObject(const CObject& objectSrc);              // no implementation  
void operator=(const CObject& objectSrc);       // no implementation

拷贝构造函数和赋值运算符重载函数在CObject只进行了声明而并没有去真正实现它们。只要我们的程序不去调用CObject类的这两个函数，那么程序就不会报错。一旦我们在程序中调用了这两个函数中的某一个，程序立马就会报错。

在这里，MFC之所以只在CObject类中声明了这两个函数而并没有去实现他们，这是为了防止在CObject的派生类中出现与“浅拷贝和深拷贝”相关的错误。如果我们想在CObject的派生类中使用这两个函数，就必须在派生类中去真正实现它们。

浅拷贝与深拷贝[http://blog.csdn.net/stone\_sky/article/details/8256234][http_blog.csdn.net_stone_sky_article_details_8256234]

=======================================数组(一维、二维、三维)的动态申请及用vector的表示方法======================================

转自：[http://www.cnblogs.com/rollenholt/articles/1907415.html][http_www.cnblogs.com_rollenholt_articles_1907415.html]

变长一维数组

这里说的变长数组是指在编译时不能确定数组长度，程序在运行时需要动态分配内存空间的数组。实现变长数组最简单的是变长一维数组，你可以这样做：

#include<iostream>
     
    using namespace std;
     
    int main()
     
    {
     
    int len;
     
    cin>>len;
     
    //用指针p指向new动态分配的长度为len*sizeof(int)的内存空间
     
    int *p=new int[len];
     
    ...........
     
    delete[] p;
     
    return 0;
     
    }

注意int \*p=new int\[len\];这一句，你不能这样做： int p\[len\]; C++编译器会报错说len的大小不能确定，因为用这种形式声明数组，数组的大小需要在编译时确定。而且这样也不行： int p\[\]=new int\[len\];编译器会说不能把int\*型转化为int\[\]型，因为用new开辟了一段内存空间后会返回这段内存的首地址，所以要把这个地址赋给一个指针，所以要用int \*p=new int\[len\];

以上程序实现了一个变长的一维数组，但是要养成一个好习惯，就是注意要注销指针p，使程序释放用new开辟的内存空间。  
当然使用C++标准模版库（STL）中的vector（向量）也可以实现变长数组：

#include<iostream>
     
    #include<vector>
     
    using namespace std;
     
    int main()
     
    {
     
    int len;
     
    cin>>len;
     
    vector<int> array(len);//声明变长数组
     
    for(int i=0;i<len;i++)
     
    {
     
    array[i]=i;
     
    cout<<array[i]<<"\t";
     
    }
     
    return 0;
     
    }

2．变长二维数组

用C++实现变长二维数组时可以采用两种方法：双指针方法和使用STL中vector（向量）的方法。

首先介绍一下双指针方法，在这里双指针就是指像指针的指针，比如你可以这样声明一个数组：

int \*\*p = new int\*\[num1\];

而对每一个\*p（一共num1个\*p）申请一组内存空间：

for(int i=0; i<num1; ++i)

p\[i\] = new int\[num2\];

其中，num1是行数，num2是数组的列数。测试的源程序如下：

#include <iostream>
     
    #include <iomanip>
     
    using namespace std;
     
    int main()
     
    {
     
    int num1;//行数
     
    int num2;//列数
     
    cout<<"Please enter the number for row and column: "<<endl;
     
    cin >> num1 >> num2;
     
    //为二维数组开辟空间
     
    int **p;
     
    p= new int*[num1];
     
    for(int i=0; i<num1; ++i)
     
    p[i] = new int[num2];
     
    for(int j=0;j<num1;j++)
     
    {
     
    for(int k=0;k<num2;k++)
     
    {
     
     p[j][k]=(j+1)*(k+1);
     
     cout<<setw(6)<<p[j][k]<<':'<<setw(8)<<&p[j][k];
     
    }
     
    cout<<endl;
     
    }
     
    //释放二维数组占用的空间
     
    for(int m=0;m<num1;m++)
     
    delete[] p[m];
     
    delete[] p;
     
    return 0;
     
    }
     
    用vector（向量）实现二维数组，以下给出源程序：
     
    #include <iostream>
     
    #include <vector>
     
    #include <iomanip>
     
    using namespace std;
     
    int main()
     
    {
     
    int i,
     
     j,
     
     m, //行数
     
     n; //列数
     
    cout << "input value for m,n:";
     
    cin>>m>>n;
     
    //注意下面这一行：vector<int后两个">"之间要有空格！否则会被认为是重载">>"。
     
    vector<vector<int> > vecInt(m, vector<int>(n));
     
    for (i = 0; i < m; i++)
     
    for (j = 0; j < n; j++)
     
     vecInt[i][j] = i*j;
     
     
     
    for (i = 0; i < m; i++)
     
    {
     
    for (j = 0; j < n; j++)
     
     cout<<setw(5)<<vecInt[i][j]<<":"<<setw(9)<<&vecInt[i][j];
     
    cout<<endl;
     
    }
     
    return 0;
     
    }

3．变长三维数组
     
    根据以上一、二维数组，可以推出三维数组的实现。以下是指针实现代码：
     
    #include <iostream>
     
    using namespace std;
     
    void main()
     
    {
     
     int ***p3;
     
     intx=3,y=2,z=2;
     
     p3=new int **[x];
     
     for (i=0;i<x;i++)
     
     {
     
     p3[i]=new int* [y];
     
     for (int j=0;j<y;j++)
     
     {
     
     p3[i][j]=new int[z];
     
     for (int k=0;k<z;k++)
     
     {
     
     p3[i][j][k]=i*j*k;
     
     }
     
     }
     
     }
     
     for (int k=0;k<z;k++)
     
     {
     
     for (int i=0;i<x;i++)
     
     {
     
     for (int j=0;j<y;j++)
     
     cout<<p3[i][j][k]<<" " ;
     
     cout<<endl;
     
     }
     
     cout<<endl;
     
     }
     
    
     for (int i=0;i<x;i++)
     
     {
     
     for (int j=0;j<y;j++)
     
     {
     
     delete [] p3[i][j];
     
     }
     
     delete [] p3[i];
     
     }
     
     delete [] p3;
     
    }
     
    以下是vector实现代码：
     
    #include <iostream>
     
    #include <vector>
     
    using namespace std;
     
    void main()
     
    {
     
     int m=2;
     
     int n=3;
     
     int l=4;
     
     vector<vector<vector<int> > > v(m,vector<vector<int> >(n,vector<int>(l)));
     
     v[1][2][3]=4;
     
     cout<<v[1][2][3]<<endl;
     
    }
     
    4．用一维动态数组表示二维、三维动态数组
     
    以下是程序代码：
     
    #include <iostream>
     
    using namespace std;
     
    void main()
     
    {
     
     int m=3,n=4,l=2;
     
     int *p2; //将表示二维数组
     
     p2=new int[m*n];
     
     int i,j,k;
     
     for (i=0;i<m;i++)
     
     for(j=0;j<n;j++)
     
     {
     
     p2[i*n+j]=i+j;
     
     }
     
     cout<<"二维数组"<<endl;
     
     for (i=0;i<m;i++)
     
     {
     
     for(j=0;j<n;j++)
     
     {
     
     cout<<p2[i*n + j]<<" ";
     
     }
     
     cout<<endl;
     
     }
     
     delete []p2;
     
     int *p3; //将表示三维数组
     
     p3=new int[m*n*l];
     
     for (k=0;k<l;k++)
     
     for (i=0;i<m;i++)
     
     for (j=0;j<n;j++)
     
     {
     
     p3[k*n*m + i*n + j]=i+j+k;
     
     }
     
     cout<<"三维数组"<<endl;
     
     for (int k=0;k<l;k++)
     
     {
     
     for (int i=0;i<m;i++)
     
     {
     
     for (int j=0;j<n;j++)
     
     cout<<p3[k*n*m + i*n + j]<<" " ;
     
     cout<<endl;
     
     }
     
     cout<<endl;
     
     }
     
     delete []p3;
     
    }

==========================================================================================

关于vector我不想多说，我假设大家都了解temlplate   和   STL。各位在任何一本C++的书上都可以找的到这些内容的(如果没有，那赶快把它扔掉)。那为什么是vector呢？我们知道vector提供了operator\[\]函数，可以像数组一样的操作，而且还有边界检查，动态改变大小。(从这点上deque也是可以的)。vector本来就是可以用来代替一维数组的，这里只介绍用它来代替二维的数组。二维以上的可以依此类推。    
   我们知道，C++的template参数是可以嵌套定义的，你可以这样定义一个模板的Instance    
    vector<vector<int>     >   array2(3);//注意>和>之间的空格。    
   这就是我们的关键，array2可以保存3个向量，向量的长度是可以改变的。array2\[i\]返回的是第i个向量。同理，array2\[i\]\[j\]返回的是第i个向量中的第j个元素。    
   问题到这里，你可能会得意的说:"我明白了，很简单吗！"。别急，还有一些细节问题：如下    
            vector<vector<int>     >   array2(3);    
            array2\[1\]\[2\]=9;    
   我保证你的程序会segement   failed,原因就是你没有指定向量的大小。用push\_back函数可以解决问题：array2\[1\].push\_back(9);但是好象不太爽。就不能用operator\[\]吗？答案是肯定的。不过要多加几个步骤，如下：    
              for(int   i=0;i<3;i++)    
                    array2\[i\].resize(3);    
   这样，你就定义了一个3X3的数组了（另一个3在   申明时定义的）。而且你可以随时改变它的大小。    
    其他的，你还可以用C++的异常机制来捕获如下标越界等非法行为。进行必要的处理。使你的程序更加的健壮。具体的方法我就不深入介绍了。留给各位自己钻研。下面提供一个范例，供参考。      
      ＃i nclude   <iostream>    
      ＃i nclude   <vector>    
      using   namespace   std;    
      void   main()    
      \{    
              vector<   vector<int>   >   array(3);    
              for(int   i=0;i<3;i++)    
                  array\[i\].resize(3);//设置数组的大小3X3    
                    //现在你可以和使用数组一样使用这个vector    
              for(int   i=0;i<3;i++)    
                  for(int   j=0;j<3;j++)    
                      array\[i\]\[j\]=(i\*j);    
              //输出    
              for(int   i=0;i<3;i++)    
              \{    
                    for(int   j=0;j<3;j++)    
                        cout<<array\[i\]\[j\]<<"   ";    
                    cout<<endl;    
                \}    
            array.resize(5);    
            arry\[3\].resize(3);    
            arry\[4\].resize(3);    
              //现在是5X3的数组了    
              for(int   i=0;i<5;i++)    
                    for(int   j=0;j<3;j++)    
                          array\[i\]\[j\]=(i\*j);    
              for(int   i=0;i<5;i++)    
              \{    
                    for(int   j=0;j<3;j++)    
                          cout<<array\[i\]\[j\]<<"   ";    
                  cout<<endl;    
              \}    
      \}

[http_blog.csdn.net_panjean_article_details_5989832]: http://blog.csdn.net/panjean/article/details/5989832
[http_blog.csdn.net_stone_sky_article_details_8256234]: http://blog.csdn.net/stone_sky/article/details/8256234
[http_www.cnblogs.com_rollenholt_articles_1907415.html]: http://www.cnblogs.com/rollenholt/articles/1907415.html