二维数组的定义

内裤里有糖吃

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

tttxiaoz

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

内裤里有糖吃

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

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

xieglt

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

#include <stdio.h>
#include <vector>
#include <iostream.h>

int main(void)
{
        //定义一个一维数组
        std::vector<double> array_1D;
        //定义一个二位数组
        std::vector<std::vector <double> > array_2D;
        
        //给一维数组中添加10个元素
        for(int i = 0 ; i < 10 ; i ++)
        {
                array_1D.push_back(i);
        }
        
        //给二维数组中添加一个一维数组
        array_2D.push_back(array_1D);

        for(i = 0 ; i < 10 ; i ++)
        {
                array_1D[i] = i * i;
        }
        //给二维数组中再添加一个一维数组
        array_2D.push_back(array_1D);
        
        //以下标方式访问二维数组，将数组中的每个元素输出
        for(i = 0 ; i < 2 ; i ++)
        {
                for(int j = 0 ; j < 10 ; j ++)
                {
                        cout << array_2D[i][j] << ",";
                }
                cout << endl;
        }
        
        //清空一维数组
        array_1D.clear();
        //给一维数组中添加11个元素
        for(i = 0 ; i <= 10 ; i++)
        {
                array_1D.push_back(i * i * i);
        }
        
        //给二维数组中再添加一个一维数组
        array_2D.push_back(array_1D);

                
        //因为一维数组的长度不一致，用下标方式访问不方便，可以用指针方式访问数组
        typedef std::vector<std::vector <double> >::iterator VVI;
        typedef std::vector<double>::iterator VI;

        for(VVI vvi = array_2D.begin() ; vvi != array_2D.end() ; vvi ++)
        {
                for(VI vi = vvi->begin() ; vi != vvi->end() ; vi ++)
                {
                        cout << * vi << ",";
                }
                cout << endl;
        }

        return 0;        
}

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

        //定义一个已经包含10个元素的一维数组，并把每一个元素初始化为1.0
        std::vector<double> array_1D(10,1.0);
        //定义一个包含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
我不太懂的点是“定义一个二维数组里面放的是另外一个二维数组”，那定义出来的二维数组是个什么样子的。

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

class aaa
{
   public:
          aaa(){m_a = 0;}
         ~aaa(){}
         aaa(const aaa & b){ m_a = b.m_a;}
         aaa & operator = (const aaa & b) { m_a = b.m_a; return * this;}
  private:
   int m_a;
}

用这个类定义两个对象

aaa a;
aaa b(a);

相当于 b = a;

vector<vector<double>> m_startAndEndVec；
vector<vector<double> > tmp_m_startAndEndVec(m_startAndEndVec);

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

tttxiaoz

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

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

xieglt

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

template <typename T>
class CMyArray  
{
public:
        CMyArray()
        {
                m_nCount = 0;
                m_pBuffer = NULL;
        }

        ~CMyArray()
        {
                safeRelease();
        }
        
        //这个叫拷贝构造函数
        CMyArray(const CMyArray<T> & arr)
        {
                m_nCount = arr.m_nCount;
                m_pBuffer = NULL;

                if(m_nCount > 0)
                {
                        m_pBuffer = new T[m_nCount];
                        for(long i = 0 ; i < m_nCount ; i ++)
                        {
                                m_pBuffer[i] = arr.m_pBuffer[i];
                        }
                }
        }
        
        CMyArray & operator = (const CMyArray & arr)
        {
                m_nCount = arr.m_nCount;
                safeRelease();
                if(m_nCount > 0)
                {
                        m_pBuffer = new T[m_nCount];
                        for(long i = 0 ; i < m_nCount ; i ++)
                        {
                                m_pBuffer[i] = arr.m_pBuffer[i];
                        }
                }
                return * this;
        }

        T & operator[](long index)
        {
                return m_pBuffer[index];
        }

        void push_back(const T & t)
        {
                int count = m_nCount++;
                T * temp = new T[m_nCount];
                
                for(int i = 0 ; i < count ; i ++)
                {
                        temp[i] = m_pBuffer[i];
                }
                
                temp[count] = t;
                safeRelease();
                m_pBuffer = temp;
        }
private:
        void safeRelease()
        {
                if(m_pBuffer != NULL)
                {
                        delete [] m_pBuffer;
                        m_pBuffer = NULL;
                }
        }
private:
        long m_nCount;
        T * m_pBuffer;
};

int  main(void)
{
        CMyArray<double> array_1D;

        for(long i = 0 ; i < 10 ; i ++)
        {
                array_1D.push_back(i);
        }

        CMyArray<CMyArray <double> > array_2D;
        array_2D.push_back(array_1D);
        
        double d = array_2D[0][5];
        //这就是你所说的那个语法
        CMyArray<CMyArray <double> > temp(array_2D);

        d = temp[0][8];

        return 0;
}