4

I'm a C beginners and I need help. I've a struct like this the following one:

    struct {
        char*   name;
        int     level;
        int     spring_prob;
        int     population;
    } Organism;

Organism with the same level have to be grouped into the same array to create a situation like that:

    +++++         +++++++++++++++++++++++++++
    | 0 |  -->    | organism_0 | organism_1 |
    +++++         ++++++++++++++++++++++++++++++++++++++++
    | 1 |         | organism_2 | organism_3 | organism_4 |
    +++++         ++++++++++++++++++++++++++++++++++++++++
    | 2 |         | organism_5 |
    +++++         ++++++++++++++
     org

In main i created an array to pointer to array of struct: 

    int main {
        ...
        Organism *org[];
        load_organism(org);
        show(org);
        return 0;
    }
    void load_organism (Organism *org[]){
        Organism o[3];
        o[0].name = "abc";
        o[0].level = 0;
        o[0].spring_prob = 25;
        o[0].population = 300;

        o[1].name = "def";
        o[1].level = 0;
        o[1].spring_prob = 25;
        o[1].population = 20;

        o[2].name = "ebs";
        o[2].level = 0;
        o[2].spring_prob = 25;
        o[2].population = 20;

        *org[0] = o;
    }
    void show (Organism* org[]) {
        print("%s", org[0][0].name);
    }

It crashes when i try to print the name of the first organism. I hope you could help me finding the error. Thanks in advance.

Improve this question
4
  • I am surprised the compiler did not treat Organism *org[]; as an error. Commented Sep 10, 2015 at 18:25
  • 1
    int main { ist not valid. Commented Sep 10, 2015 at 18:26
  • 1
    What compiler and toolchain are you using? The code you've posted is not valid C. Commented Sep 10, 2015 at 18:34
  • you have not allocated org Commented Sep 10, 2015 at 20:19

4 Answers 4

Reset to default
3

You should be seeing a number of compiler warnings with that code.

For example, when you assign o (which is an Organism[]) to *org[0], which is an Organism. Heed those warnings.

In this case, you mean to say:

org[0] = o;

But that will fail eventually, since o is a local variable, and its memory will be discarded when the function returns.

Create it, instead, as:

Organism *o = malloc(3 * sizeof(Organism));

Once those are cleaned up, you'll need to actually allocate some memory to org, which is uninitialized. Bad news when you assign to its members.

Either give the array a specific size like so:

Organism *org[10];

or allocate it as above:

Organism **org = malloc(10 * sizeof(Organism *));

or

Organism **org = calloc(10, sizeof(Organism *));

When the program exits, be sure to free() any members of org, and org itself if you go the malloc() route.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

calloc is specifically useful here to (1) provide a sentinel null following the last assigned organism to aid in iteration, and (2) to prevent the unintentional attempted access of an uninitialized value. In many situations calloc provides significant advantage over malloc, especially in saving a new C programmer from him or her selves.
1

Note that you are defining an empty array of pointers to Organism. Then you access offset 0 of this array (which is already undefined behavior) and the garbage that is there used as a pointer to a memory which should now hold the copy of o. (Also I don't know how you managed to compile this line: *org[0] = o;)

Agree with me that even you would segfault at some moment :).

Either define a fixed size of this array:

#define NUM_OF_ORGANISMS 10

int main()
{
    Organism *org[NUM_OF_ORGANISMS];
    ....
}

and then in load_organism you need actually to allocate the memory for the new Organism:

org[0] = malloc(sizeof(Organism));
*org[0] = o[0];

Or define org as

Organism** org;

And then dynamically allocate the size of the array and each entry of it.

org = malloc(sizeof(Organism*)*NUM_OF_ORGANISMS);
....
org[i] = malloc(sizeof(Organism));
...
// now you can access it
*org[i] = ...

P.S.

And don't forget to free the memory after you finish using it :)

Improve this answer

1 Comment

Organism *org[]; is illegal code , it is not an empty array or anything else. There are no empty arrays in C.
0

The array Organism o[3]; scope is limited to the function void load_organism().

You are trying to access it after the function has exited. This invokes undefined behavior.

Improve this answer

Comments

0
  • You must mean that org[0] = o; instead of *org[0] = o;. So, it means o and org[0] are pointer to same address.
  • However, you must mean printf("%s", org[0]->name); instead of
    print("%s", org[0][0].name);.
  • Besides, If you want to use Organism like in main() and functions, you should add typedef to your struct.
  • You need to initialize explicit size of the struct array or allocation
  • Eventually, o is of course local variable for load_organism after function invoking it will be destroyed. You should use malloc()

Fixed code:

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

typedef struct {
    char*   name;
    int     level;
    int     spring_prob;
    int     population;
} Organism;

void load_organism (Organism *org[]){
    Organism *o = malloc(3 * sizeof(Organism));
    o[0].name = "abc";
    o[0].level = 0;
    o[0].spring_prob = 25;
    o[0].population = 300;

    o[1].name = "def";
    o[1].level = 0;
    o[1].spring_prob = 25;
    o[1].population = 20;

    o[2].name = "qwe";
    o[2].level = 0;
    o[2].spring_prob = 25;
    o[2].population = 20;

    org[0] = o;
}
void show (Organism* org[]) {
    printf("%s", org[0]->name);
}

int main()
{
    Organism *org[3];
    load_organism(org);
    show(org);
    return 0;
}
Improve this answer

2 Comments

This is UB - you're referencing memory from o after leaving the scope of load_organism.
Downvote removed; the original code had o as a local prior to editing, which must have been within the 5-minute grace period.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.