Question

您好我正在处理C ++中的嵌套结构和数组，这里有一些背景信息：

 struct Cells // a collection of data cells lines 

     cells :: [Cell] // the cells: a location and a value 

     nCells :: Integer // number of cells in the array

     capacity :: Integer // maximum size of the array end 



struct Cell 
      location :: int // a location of data cells lines 
      value :: int // the value end Cells

我没有编译的代码（3个文件，标题，ADT实现，主要）我如何在struct array中声明嵌套结构错误？

// Defines the  cell.h ADT interface
struct Cell;
struct Cells;


struct Cells {
    Cell cells[];
    int nCells;
   int capacity;
};

struct Cell {
   int location;
   int value;
};

//fill cells with random numbers
void initialize(Cells *rcells);

ADT实施

using namespace std;

#include <iostream>
#include <cstdlib>
#include "cell.h"

void initialize(Cells *rcells){
    for(int i = 0 ; i < rcells->nCells; i++)
   {
        rcells->cells[i].location = rand() % 100;
        rcells->cells[i].value = rand() % 1000;
    }
}

主

using namespace std;

#include <iostream>
#include <cstdlib>
#include "cell.h"

int main(){
    Cells *c;
    c->cells[0].location=0;
    c->cells[0].value=0;
    c->cells[1].location=0;
    c->cells[1].value=0;
    c->nCells = 2;
    c->capacity = 2;
    initialize(c);
}

Answer 1

原始声明失败，因为

struct Cells {
    Cell cells[];
    int nCells;
    int capacity;
};

以这种方式定义的“单元格”是一个数组，它应该有固定的大小（除非它是最后一个成员，你使用的是C99标准）。您可能认为它与

相同

Cell* cells

但它不会在struct definition中自动转换为指针类型。

C ++做这些事情的方法是

typedef std::vector<Cell> Cells;

您的初始化功能可能是

void initialize(int ncell, Cells& cells) {
    cells.resize(ncell);
    for (Cell& cell : cells)
    {
         cell.location = rand() % 100;
         cell.value = rand() % 1000;
    }
}

你的主程序应该改变一点

int main(){
    Cells c;
    initialize(2, c);

    c[0].location=0;
    c[0].value=0;
    c[1].location=0;
    c[1].value=0;
}

如果您想要细胞计数信息，可以致电

c.size()

不需要容量变量，因为单元格总数没有上限。

顺便说一句，这不是人们通常谈论的嵌套结构。当人们说嵌套结构时，他通常意味着嵌套的结构定义。包含其他对象的对象没有什么特别之处。

Answer 2

与其他一些编程语言不同，当您在C或C ++中声明一个数组时，会在您声明它的地方创建它。例如，如果将一个声明为函数局部变量，则将在堆栈上创建它。

在你的情况下Cell cells[];声明一个必须在你的类中创建的数组。因此，如果您的类具有四个元素的数组，则编译器需要为该字段的每个实例4*sizeof(Cell)字节分配，以便它可以适合实例中的数组。如果您的数组有524个元素，则需要524*sizeof(Cell)个字节。

你在这里看到问题：编译器无法猜出你的对象的大小。获取实例中每个字段的位置是有问题的，特别是如果声明两个没有大小的数组。请注意，此问题不仅限于对象字段：例如，您不能在不给出大小的情况下将数组声明为函数中的局部变量。这是因为阵列具有在创建时确定的固定大小。因此，无论您在何处创建数组，都必须提供其大小。

当您将Cell array[]写为函数参数时，您不是在创建数组，而只是获取指向它的指针，所以不给它的大小是可以的。

要解决您的问题，您必须以某种方式制作具有恒定大小的类。例如，您可以使用new[some_variable]动态分配数组，并在类中使用指针Cell *cells;。指针有一个固定的大小，你的数组将在堆上声明（不要忘记它delete[]）。

备注：仅提供数组初始值设定项而不是大小有效：

int x[] = {1, 2, 4}; //creates an array of three elements

嵌套结构和数组C ++

2 个答案: