将结构数组传递给函数？

Question

我想学习如何通过引用将结构数组传递给从second function调用/执行的first function 。 我的目标是修改/从武断改变结构的内容， second function 而已 。 下面的代码可以正常工作，但是不幸的是，它并不能完全实现我想要的目标。 我将可以在second function访问任意结构。 换句话说，我想处理所有的结构（使用for内环路） second function调用/执行first function在main只有一次 ，不使用for循环。

在下面的代码中， second function名为passByReference_inner 。

array_of_struct.h：

struct card
{
    int face;
    int nose;
};

typedef struct card HEAD ;

/* prototype */
extern void passByReference(HEAD **c);      /* first function */
extern void passByReference_inner(HEAD *c); /* second function */

第一个功能： （passByReference）

#include <stdio.h>
#include "array_of_struct.h"

void passByReference(HEAD **c)
{
    passByReference_inner (*c);   /* second function */
}

第二个功能： （passByReference_inner）

#include <stdio.h>
#include "array_of_struct.h"

void passByReference_inner(HEAD *c)
{
    c->face = (c->face) + 1000;
    c->nose = (c->nose) + 2000;
}

主要：

#include <stdio.h>
#include "array_of_struct.h"

int main(void)
{
    int             i;
    static HEAD     c[12];
    static HEAD *cptr[12];

    for ( i = 0; i < 12; i++ )
    {
        c[i].face = i + 30;
        c[i].nose = i + 60; 
        cptr[i]   = &c[i];
    }

    for ( i = 0; i < 12; i++ )
    {
        passByReference(&cptr[i]);  /* first function */
    }
    return 0;
}

Answer 1

我想你想做的是

#include <stdio.h>

struct card
{
    int face;
    int nose;
};

typedef struct card HEAD ;

/* prototype */
void passByReference(HEAD *c, int count);      /* first function */
void passByReference_inner(HEAD *c); /* second function */

void passByReference(HEAD *c, int count)
{
    int i;
    for (i = 0 ; i < count ; i++)
        passByReference_inner (&(c[i]));   /* second function */
}

void passByReference_inner(HEAD *c)
{
    c->face = (c->face) + 1000;
    c->nose = (c->nose) + 2000;
}

int main(void)
{
    int  i;
    HEAD c[12]; /* you don't need static here (do you know what static is for?) */

    for ( i = 0; i < 12; i++ )
    {
        c[i].face = i + 30;
        c[i].nose = i + 60;
    }
    /* 
     * the element count of the array is sizeof(c) / sizeof(c[0]) 
     *    (totalSizeOfArray) / (indivudualElementSizeOfArray).
     */
    passByReference(c, sizeof(c) / sizeof(c[0]));  /* first function */

    return 0;
}

您应该知道的是， c中的数组在作为参数传递给函数时会衰减为指向其第一个元素的指针。

因为您要处理第二个函数中的所有结构，所以我看不到第一个函数的需要，反正这就是您的处理方式

#include <stdio.h>

struct card
{
    int face;
    int nose;
};

typedef struct card HEAD ;

/* prototype */
void passByReference(HEAD *const c, int count);      /* first function */
void passByReference_inner(HEAD *const c, int count); /* second function */

void passByReference(HEAD *const c, int count)
{
    passByReference_inner(c, count);   /* second function */
}

/* HEAD *const c prevents the pointer c to be changed
 * this way it will never point anywhere else.
 *
 * And you can be sure to alter the original data.
 */
void passByReference_inner(HEAD *const c, int count)
{
    for (int i = 0 ; i < count ; ++i)
    {
        c[i].face = (c[i].face) + 1000;
        c[i].nose = (c[i].nose) + 2000;
    }
}

int main(void)
{
    int  i;
    HEAD c[12]; /* you don't need static here (do you know what static is for?) */

    for ( i = 0; i < 12; i++ )
    {
        c[i].face = i + 30;
        c[i].nose = i + 60;
    }
    /* 
     * the element count of the array is sizeof(c) / sizeof(c[0]) 
     *    (totalSizeOfArray) / (indivudualElementSizeOfArray).
     */
    passByReference(c, sizeof(c) / sizeof(c[0]));  /* first function */

    return 0;
}

由于您实际上是在传递指针，因此您可以直接在第一个和第二个函数中直接更改其内容。

还有一件事，您实际上并不需要static关键字，特别是在main() ， static保留函数调用之间的变量值，并且由于main()通常在程序生命周期中仅被调用一次。 。在那儿使用static没有多大意义。

Answer 2

您的第二个功能是正确的。

指向数组第一个元素的指针实际上与指向数组本身的指针相同。

你应该做的是

void passByReference_inner(HEAD *c, size_t n)
{
}

因此，您将把指针传递给数组的第一个元素以及数组中的元素数，如下所示：

passByReference(c, sizeof(c)/sizeof(c[0]));

这会将指针传递到c数组的第一个元素，并将数组中的元素数传递给passByReference_inner（）。 sizeof（c）是整个数组的大小（以字节为单位）。 sizeof（c [0]）是数组中元素的大小。 因此，例如，如果每个结构的长度为10个字节（仅作为示例），而您有12个结构的数组，则整个数组的大小为120个字节，这将计算出值120/10 = 12，则数组中元素的数量，自动。

当您使用数组对象的名称时，在C / C ++中，它会自动成为指向数组第一个元素的指针。

在函数中，可以按以下方式使用数组：

void passByReference_inner(HEAD *c, size_t n)
{
    for (size_t i=0; i<n; i++)
    {
        HEAD *p=c+i;

        // p is now a pointer to the ith element of the array
    }
}

向指针添加整数n会使指针前进到数组的下一个nth元素。 向指针添加整数值不会使指针超前此字节数，而是指针所指向的对象中的字节数乘以您要添加（或减去，等于）的数字。 这使指针算法可以正确地执行操作。

Answer 3

• 以下代码可以干净地编译。
• 以下代码移动了增量值循环
  到passByReference（）函数内部。

---

/* 
 * Note: guard code is used in a header file
 *       so the header file can only be included once
 *       in each compilation unit 
 */

// note the inclusion of a 'guard' wrapper
// begin: array_of_struct.h file
#ifndef ARRAY_OF_STRUCT_H
#define ARRAY_OF_STRUCT_H

struct card
{
    int face;
    int nose;
};

// dont obsecure the code with useless typedef statements
//typedef struct card HEAD ;

#define MAX_CARDS (12)

/* prototype */
extern void passByReference(struct card *pCards);      /* first function */
extern void passByReference_inner(struct card *pCard); /* second function */
#endif
// end: array_of_struct.h


//first function: (passByReference), in different file

#include <stdio.h>
#include "array_of_struct.h" 

void passByReference(struct card *pCards)
{
    int i=0; // loop index

    for(i=0;i<MAX_CARDS;i++)
    {
        passByReference_inner (&pCards[i]);   /* second function */
    } // end for
} // end function: passByReference

// second function: (passByReference_inner), in different file

#include <stdio.h>
#include "array_of_struct.h"

void passByReference_inner(struct card *pCard)
{
    pCard->face = (pCard->face) + 1000;
    pCard->nose = (pCard->nose) + 2000;
} // end function: passByReference_inner

//main, in a different file

#include <stdio.h>
#include "array_of_struct.h"

int main()
{
    int i = 0; // loop index
    static struct card     cards[MAX_CARDS];

    for ( i = 0; i < MAX_CARDS; i++ )
    {
        cards[i].face = i + 30;
        cards[i].nose = i + 60;
    } // end for

    passByReference(&cards[0]);  /* first function gets ptr to whole array*/
    // could also be written as:
    // passByReference(cards);

    return 0;
} // end function: main

Answer 4

我分析了所有三个解决方案（iharob，user3629249，Sam Varshavchik），得出的结论是，Sam Varshavchik和iharob的第二个解决方案确实物有所值。 本质上，第一个iharob的解决方案和user3629249解决方案是相等的。 他们从main转到第first function for循环。 iharob帖子的第二个解决方案符合初始帖子的要求。 山姆的解决方案给了我足够的提示/指令“如何移动for循环从主到second function （这是，基本上，我不知道如何做到这一点，因此要求帮助）。

因此，总而言之，这是实现几乎所有贡献者的所有建议的源代码。 该代码可以干净地编译，因此像我这样的初学者可以直接使用它，并学到一些有关指针的指针，指针算术以及结构数组的详细信息。

array_of_struct.h （头文件）

#ifndef ARRAY_OF_STRUCT_H
#define ARRAY_OF_STRUCT_H

/* HEAD structure definition */
typedef struct
{
    int face;
    int nose;
} HEAD;       // end structure HEAD

#define MAX_HEADS (12)

/* prototype */
extern void passByReference(HEAD **c, size_t n);
extern void passByReference_inner(HEAD *c, size_t n);

#endif

passByReference.c （第一个函数）

#include <stdio.h>
#include "array_of_struct.h"

void passByReference(HEAD **c, size_t n)
{
    passByReference_inner (*c, n);
}

passByReference_inner.c （第二个功能）

#include <stdio.h>
#include "array_of_struct.h"

void passByReference_inner(HEAD *c, size_t n)
{
    int   i;
    HEAD *p;

    printf("\nPOINTER ARITHMETIC: The value of struct's  members after PASS BY REFERENCE \n");
    for ( i = 0; i < n; i++ )
    {
        p = c + i;

        p->face = (p->face) + 1000;
        p->nose = (p->nose) + 2000;
        printf("struct[%i].face = %d  \n",i, p[0].face);
        printf("struct[%i].nose = %d  \n",i, p[0].nose);
    }

    printf("\nARRAY INDEX MATH: The value of struct's  members after PASS BY REFERENCE\n");
    printf("[NOTE: structs were updated in the for loop above]\n");
    for ( i = 0; i < n; i++ )
    {
        printf("struct[%i].face = %d  \n",i, c[i].face);
        printf("struct[%i].nose = %d  \n",i, c[i].nose);
    }
}

main.c中

#include <stdio.h>
#include "array_of_struct.h"

int main(void)
{
    int     i;
    HEAD    c[MAX_HEADS];
    HEAD   *cptr;
    size_t  n;

    n = (sizeof(c) / sizeof(c[0]);

    printf("\nINITIALIZATION of all struct's  members\n");
    for ( i = 0; i < n; i++ )
    {
        c[i].face = i + 30;
        c[i].nose = i + 60; 
        printf("struct[%i].face = %d\n",i, c[i].face);
        printf("struct[%i].nose = %d\n",i, c[i].nose);
    }

    cptr = &c[0];
    passByReference(&cptr, n); 

    return 0;
}