二维数组的定义

内裤里有糖吃

vector<vector<double>> m_startAndEndVec；
vector<vector<double> > tmp_m_startAndEndVec(m_startAndEndVec);
请问这算什么定义呀？

tttxiaoz

就是一个简单的容器的嵌套  严格上不能称为二维数据

内裤里有糖吃

tttxiaoz 发表于 2020-10-9 16:41
就是一个简单的容器的嵌套  严格上不能称为二维数据

这样嵌套之后，他的容量是多大呢？不是二维数组嘛?

xieglt

vector容器的大小是不定长的。

1. 
   
2. #include <stdio.h>
   
3. #include <vector>
   
4. #include <iostream.h>
   
5. 
   
6. int main(void)
   
7. {
   
8.         //定义一个一维数组
   
9.         std::vector<double> array_1D;
   
10.         //定义一个二位数组
    
11.         std::vector<std::vector <double> > array_2D;
    
12.        
    
13.         //给一维数组中添加10个元素
    
14.         for(int i = 0 ; i < 10 ; i ++)
    
15.         {
    
16.                 array_1D.push_back(i);
    
17.         }
    
18.        
    
19.         //给二维数组中添加一个一维数组
    
20.         array_2D.push_back(array_1D);
    
21. 
    
22.         for(i = 0 ; i < 10 ; i ++)
    
23.         {
    
24.                 array_1D[i] = i * i;
    
25.         }
    
26.         //给二维数组中再添加一个一维数组
    
27.         array_2D.push_back(array_1D);
    
28.        
    
29.         //以下标方式访问二维数组，将数组中的每个元素输出
    
30.         for(i = 0 ; i < 2 ; i ++)
    
31.         {
    
32.                 for(int j = 0 ; j < 10 ; j ++)
    
33.                 {
    
34.                         cout << array_2D[i][j] << ",";
    
35.                 }
    
36.                 cout << endl;
    
37.         }
    
38.        
    
39.         //清空一维数组
    
40.         array_1D.clear();
    
41.         //给一维数组中添加11个元素
    
42.         for(i = 0 ; i <= 10 ; i++)
    
43.         {
    
44.                 array_1D.push_back(i * i * i);
    
45.         }
    
46.        
    
47.         //给二维数组中再添加一个一维数组
    
48.         array_2D.push_back(array_1D);
    
49. 
    
50.                
    
51.         //因为一维数组的长度不一致，用下标方式访问不方便，可以用指针方式访问数组
    
52.         typedef std::vector<std::vector <double> >::iterator VVI;
    
53.         typedef std::vector<double>::iterator VI;
    
54. 
    
55.         for(VVI vvi = array_2D.begin() ; vvi != array_2D.end() ; vvi ++)
    
56.         {
    
57.                 for(VI vi = vvi->begin() ; vi != vvi->end() ; vi ++)
    
58.                 {
    
59.                         cout << * vi << ",";
    
60.                 }
    
61.                 cout << endl;
    
62.         }
    
63. 
    
64.         return 0;       
    
65. }

复制代码

可以在定义时指定长度，但它依然可以变长

1. 
   
2.         //定义一个已经包含10个元素的一维数组，并把每一个元素初始化为1.0
   
3.         std::vector<double> array_1D(10,1.0);
   
4.         //定义一个包含5个元素的二维数组。
   
5.         std::vector<std::vector <double> > array_2D(5);
   

复制代码

内裤里有糖吃

xieglt 发表于 2020-10-10 16:54
vector容器的大小是不定长的。

我不太懂的点是“定义一个二维数组里面放的是另外一个二维数组”，那定义出来的二维数组是个什么样子的。

内裤里有糖吃

内裤里有糖吃 发表于 2020-10-12 14:13
我不太懂的点是“定义一个二维数组里面放的是另外一个二维数组”，那定义出来的二维数组是个什么样子的。

xieglt

内裤里有糖吃 发表于 2020-10-12 14:13
我不太懂的点是“定义一个二维数组里面放的是另外一个二维数组”，那定义出来的二维数组是个什么样子的。

做个简单的比方,定义一个类

1. 
   
2. class aaa
   
3. {
   
4.    public:
   
5.           aaa(){m_a = 0;}
   
6.          ~aaa(){}
   
7.          aaa(const aaa & b){ m_a = b.m_a;}
   
8.          aaa & operator = (const aaa & b) { m_a = b.m_a; return * this;}
   
9.   private:
   
10.    int m_a;
    
11. }
    

复制代码

用这个类定义两个对象

1. 
   
2. aaa a;
   
3. aaa b(a);
   

复制代码

相当于 b = a;

1. 
   
2. vector<vector<double>> m_startAndEndVec；
   
3. vector<vector<double> > tmp_m_startAndEndVec(m_startAndEndVec);
   

复制代码

这样的语法同理， tmp_m_startAndEndVec 相当于 m_startAndEndVec 的一个拷贝。

tttxiaoz

内裤里有糖吃 发表于 2020-10-10 15:26
这样嵌套之后，他的容量是多大呢？不是二维数组嘛?

容器的长度是根据添加元素个数决定的 具体分配的大小 你可以写代码  用size和capacity测一下

xieglt

一个简单的数组类的实现，你可以看一下。

1. template <typename T>
   
2. class CMyArray  
   
3. {
   
4. public:
   
5.         CMyArray()
   
6.         {
   
7.                 m_nCount = 0;
   
8.                 m_pBuffer = NULL;
   
9.         }
   
10. 
    
11.         ~CMyArray()
    
12.         {
    
13.                 safeRelease();
    
14.         }
    
15.        
    
16.         //这个叫拷贝构造函数
    
17.         CMyArray(const CMyArray<T> & arr)
    
18.         {
    
19.                 m_nCount = arr.m_nCount;
    
20.                 m_pBuffer = NULL;
    
21. 
    
22.                 if(m_nCount > 0)
    
23.                 {
    
24.                         m_pBuffer = new T[m_nCount];
    
25.                         for(long i = 0 ; i < m_nCount ; i ++)
    
26.                         {
    
27.                                 m_pBuffer[i] = arr.m_pBuffer[i];
    
28.                         }
    
29.                 }
    
30.         }
    
31.        
    
32.         CMyArray & operator = (const CMyArray & arr)
    
33.         {
    
34.                 m_nCount = arr.m_nCount;
    
35.                 safeRelease();
    
36.                 if(m_nCount > 0)
    
37.                 {
    
38.                         m_pBuffer = new T[m_nCount];
    
39.                         for(long i = 0 ; i < m_nCount ; i ++)
    
40.                         {
    
41.                                 m_pBuffer[i] = arr.m_pBuffer[i];
    
42.                         }
    
43.                 }
    
44.                 return * this;
    
45.         }
    
46. 
    
47.         T & operator[](long index)
    
48.         {
    
49.                 return m_pBuffer[index];
    
50.         }
    
51. 
    
52.         void push_back(const T & t)
    
53.         {
    
54.                 int count = m_nCount++;
    
55.                 T * temp = new T[m_nCount];
    
56.                
    
57.                 for(int i = 0 ; i < count ; i ++)
    
58.                 {
    
59.                         temp[i] = m_pBuffer[i];
    
60.                 }
    
61.                
    
62.                 temp[count] = t;
    
63.                 safeRelease();
    
64.                 m_pBuffer = temp;
    
65.         }
    
66. private:
    
67.         void safeRelease()
    
68.         {
    
69.                 if(m_pBuffer != NULL)
    
70.                 {
    
71.                         delete [] m_pBuffer;
    
72.                         m_pBuffer = NULL;
    
73.                 }
    
74.         }
    
75. private:
    
76.         long m_nCount;
    
77.         T * m_pBuffer;
    
78. };
    

复制代码

1. int  main(void)
   
2. {
   
3.         CMyArray<double> array_1D;
   
4. 
   
5.         for(long i = 0 ; i < 10 ; i ++)
   
6.         {
   
7.                 array_1D.push_back(i);
   
8.         }
   
9. 
   
10.         CMyArray<CMyArray <double> > array_2D;
    
11.         array_2D.push_back(array_1D);
    
12.        
    
13.         double d = array_2D[0][5];
    
14.         //这就是你所说的那个语法
    
15.         CMyArray<CMyArray <double> > temp(array_2D);
    
16. 
    
17.         d = temp[0][8];
    
18. 
    
19.         return 0;
    
20. }

复制代码