C 如何使用指向包含指向另一个具有多个指针的结构的指针的结构的多个指针？_C_Pointers_Struct

C 如何使用指向包含指向另一个具有多个指针的结构的指针的结构的多个指针？

c pointers struct

C 如何使用指向包含指向另一个具有多个指针的结构的指针的结构的多个指针？,c,pointers,struct,C,Pointers,Struct,我试图使用指向一个结构的指针数组，该结构中有指向另一个结构的指针，该结构正与指针数组一起使用我可以为两个单一的结构编写代码，它可以工作。但是，我不知道如何处理指针数组的引入。示例代码： typedef struct { double vx; } particle_t; typedef struct { int m; int n; particle_t *inparticles; // Pointer to particles inside gr

我试图使用指向一个结构的指针数组，该结构中有指向另一个结构的指针，该结构正与指针数组一起使用

我可以为两个单一的结构编写代码，它可以工作。但是，我不知道如何处理指针数组的引入。示例代码：

typedef struct {
    double vx;
} particle_t;
    
typedef struct {
    int m;
    int n;
    particle_t *inparticles;    // Pointer to particles inside grid
} grid_t;
    
particle_t *particles = (particle_t*) malloc( 3 * sizeof(particle_t) );
grid_t *grid = (grid_t*) malloc( 3 * sizeof(grid_t) ); // trying 3 pointers

if( particles==NULL || grid==NULL ){
    puts("Unable to allocate memory");
    exit(1);}

// fill the structure 
grid[1].inparticles = particles[1]; // I am not sure how to link these
grid[2].inparticles = particles[2]; // these lines give incompatible types error
grid[3].inparticles = particles[3];
grid[1].m = 5;
grid[1].n = 3;
grid[1].inparticles -> vx = 15;

提前谢谢你

更新：

我意识到我应该做的是使用inparticles指针指向同一网格指针中的多个粒子？我如何更改代码，以便能够做到这一点？例如：

grid[0].inparticles[0] = particles[0];
grid[0].inparticles[1] = particles[1];
grid[0].inparticles[2] = particles[2];

以某种方式将其声明为数组？我也需要为它分配内存吗？

粒子的每个成员都有类型

粒子。grid\u t
的inparticles
成员具有类型particle\u t*
。所以你想要：
grid[1].inparticles = &particles[1];
grid[2].inparticles = &particles[2];
grid[3].inparticles = &particles[3];

针对更新，如果希望inparticles
指向particles
的各种成员，则需要将inparticles
更改为指向指针的指针：
typedef struct {
    int m;
    int n;
    particle_t **inparticles;
} grid_t;

然后必须为指针数组分配空间，然后分配每个指针：
grid[0].inparticles = malloc(3 * sizeof(particle_t *));
grid[0].inparticles[0] = &particles[0];
grid[0].inparticles[1] = &particles[1];
grid[0].inparticles[2] = &particles[2];

particles
的每个成员都有类型particle\u t
。grid\u t
的inparticles
成员具有类型particle\u t*
。所以你想要：
grid[1].inparticles = &particles[1];
grid[2].inparticles = &particles[2];
grid[3].inparticles = &particles[3];

针对更新，如果希望inparticles
指向particles
的各种成员，则需要将inparticles
更改为指向指针的指针：
typedef struct {
    int m;
    int n;
    particle_t **inparticles;
} grid_t;

然后必须为指针数组分配空间，然后分配每个指针：
grid[0].inparticles = malloc(3 * sizeof(particle_t *));
grid[0].inparticles[0] = &particles[0];
grid[0].inparticles[1] = &particles[1];
grid[0].inparticles[2] = &particles[2];

问题
设计
我试图使用指向一个结构的指针数组，该结构中有指向另一个结构的指针，该结构正与指针数组一起使用
换句话说，我们必须找到一种方法来设计“指向结构的指针数组，其中包含指向另一个结构的指针作为数组”
我将集中讨论这个问题
指针数组
但是，我不知道如何处理指针数组的引入
我们在你的代码中没有任何指针数组。。。您必须先创建一个
C指针、数组、结构及其所有组合在internet上有无数线程，这些线程已被多次应答。我将向你们展示一些基本的例子，这样你们就可以开始运行了，只是别指望我给你们上一堂完整的指针课

解决
设计
下面是代码（我更改了一些变量名以使其更具可读性）：
这可以从左到右理解为：“从指针数组网格
，获取索引为0的元素（指向网格
结构的第一个指针）。访问其结构成员粒子
，即指针。将该指针视为数组，获取索引为2的元素（第三个粒子
结构）。访问其成员值
并为其指定值2.7182“
然后可以执行类似于将一个粒子复制到另一个粒子的操作：
grids[1]->particles[1] = grids[0]->particles[2];

这里有一些链接可以更好地理解指针、数组和结构。实践和实验是处理这些问题的最佳方法：






使现代化
我意识到我应该做的是使用inparticles指针指向同一网格指针中的多个粒子
我需要使用一个单独的指向粒子的指针数组。网格结构中的数组只指向粒子的子集
目标：“使用粒子内指针指向多个（连续或非连续？）粒子（在其他地方管理）的子集”
如果需要顺序解决方案，可以使用指针，表示指向数组基址（或偏移量，如果只需要子集）的指针（即指向数组的指针）。这样做的优点是不需要为每个指针分配额外内存（因为只需要基址），但它的缺点是只能访问彼此相邻的粒子
例如：
typedef struct
{
    int width;
    int height;
    Particle *subparticles; //Represents a pointer to an array subset
}Grid;

但是，如果您想要非顺序解决方案，则可以使用双指针（表示指针数组），同时必须手动为数组分配内存。这为您提供了更大的灵活性，但代价是内存分配开销
typedef struct
{
    /*...other members...*/
    Particle **subparticles;
}Grid;

Grid *createGrid(int subparticlesCount)
{
    Grid *result = malloc(sizeof(Grid));
    if (result == NULL)
    {
        printf("Error while allocating memory for the grid structure!\n");
        exit(1);
    }else
    {
        result->subparticles = malloc(sizeof(Particle *) * subparticlesCount);
    }
    return result;
}

问题
设计
我试图使用指向一个结构的指针数组，该结构中有指向另一个结构的指针，该结构正与指针数组一起使用
换句话说，我们必须找到一种方法来设计“指向结构的指针数组，其中包含指向另一个结构的指针作为数组”
我将集中讨论这个问题
指针数组
但是，我不知道如何处理指针数组的引入
嗯，我们在您的代码中没有任何指针数组……您必须先创建一个
C指针、数组、结构及其所有组合在互联网上有无数的线程，这些线程已经被回答了好几次。我将向您展示一些基本示例，这样您就可以启动并运行了，只是不要指望我给您上一堂指针的全部课程

解决
设计
下面是代码（我更改了一些变量名以使其更具可读性）：
这可以从左到右理解为：“从指针数组网格
，获取索引为0的元素（指向网格
结构的第一个指针）。访问其结构成员粒子
，即指针。将该指针视为数组，获取索引为2的元素（第三个粒子
结构）。访问其成员值并为其赋值
    /*...*/

    grids[0]->subparticles[0] = &particles[1];
    grids[0]->subparticles[1] = &particles[5];
    grids[0]->subparticles[2] = &particles[3];
    grids[1]->subparticles[0] = &particles[3];

    printf("%f equals %f", grids[0]->subparticles[2]->value, grids[1]->subparticles[0]->value);

    /*...*/

typedef struct {
  int m;
  int n;
  unsigned count;
  particle_t inparticle_arr[];    // flexible array of count elements
} grid_t;

#include<stdio.h>
#include<stdlib.h>

typedef struct {
    double vx;
} particle_t;

typedef struct {
    int m;
    int n;
    particle_t **inparticles;    // inparticles is a pointer to (array of 
                                // pointers to inparticle)
    int size; // max number of particles in the grid
} grid_t;

grid_t *new_grid(int size) { // A helper function to create grid
    grid_t *grid = (grid_t*)malloc(sizeof(grid_t));
    grid->inparticles = (particle_t**)malloc(sizeof(particle_t*));

    if(grid == NULL || grid->inparticles == NULL) return NULL;

    grid->size = size;

    for(int i=0;i<size;++i) {
        grid->inparticles[i] = (particle_t*)malloc(sizeof(particle_t));
        if(grid->inparticles[i] == NULL) {
            return NULL;
        }
    }

    return grid;
}
int main() {
    particle_t *particles = (particle_t*)malloc( 3 * sizeof(particle_t) );

    //create a new grid which can contain multiple particles --- Use a for 
    //loop for creating multiple grids 
    grid_t *grid = new_grid(3);

    if( particles==NULL || grid==NULL ){
        puts("Unable to allocate memory");
        exit(1);
    }

    grid->inparticles[0] = &particles[0];
    grid->inparticles[1] = &particles[1];
    grid->inparticles[2] = &particles[2];

    return 0;
}

particle_t* partAddr = malloc(sizeof(particle_t) * numParticles);

grid_t* gridAddr = malloc(sizeof(grid_t) * numGrids);

gridAddr[n].inparticles = partAddr;

grid[0].inparticles[0].vx= 3;

// Define the size of each array of particles
#define ELEMENTS_ARRAY_PARTICLE_A 5
#define ELEMENTS_ARRAY_PARTICLE_B 2
#define ELEMENTS_ARRAY_PARTICLE_C 7

// Create indexes and size to avoid out of boundaries accesses
enum GRID_PARTICLES {
    ARRAY_PARTICLE_0 = 0,
    ARRAY_PARTICLE_1,
    ARRAY_PARTICLE_2,
    GRID_SIZE
};

typedef struct {
    double vx;
} particle_t;

typedef struct {
    particle_t *inparticles;
} grid_t;

particle_t* allocateArrayOfParticles(int numParticles) {
    particle_t* partAddr = malloc(sizeof(particle_t) * numParticles);
    if(partAddr == NULL){
        // trigger an error
    }
    return partAddr;
}

void deallocateArrayOfParticles(particle_t *partAddr) {
    free(partAddr);
}


grid_t* allocateGridOfParticles(int numGrids) {
    grid_t* gridAddr = malloc(sizeof(grid_t) * numGrids);
    if(gridAddr == NULL) {
        // trigger an error
    }
    return gridAddr;
}

void deallocateGridOfParticles(grid_t *gridAddr) {
    free(gridAddr);
}

int main(void) {    
    grid_t *grid = allocateGridOfParticles(GRID_SIZE);
    particle_t *partA = allocateArrayOfParticles(ELEMENTS_ARRAY_PARTICLE_A);
    particle_t *partB = allocateArrayOfParticles(ELEMENTS_ARRAY_PARTICLE_B);
    particle_t *partC = allocateArrayOfParticles(ELEMENTS_ARRAY_PARTICLE_C);
  
    grid[ARRAY_PARTICLE_0].inparticles = partA;
    grid[ARRAY_PARTICLE_1].inparticles = partB;
    grid[ARRAY_PARTICLE_2].inparticles = partC;

    deallocateArrayOfParticles(partA);
    deallocateArrayOfParticles(partB);
    deallocateArrayOfParticles(partC);
    deallocateGridOfParticles(grid);
}