Which of the following two ways of using C structs in a for loop is preferred?

Let's say that we want do some operations in a for loop involving a struct. This struct will contain an element which is a pointer to char. So something of the following form:

struct foo
{
    char *s;    
}foo;

struct foo *new_foo(){
    struct foo *myfoo = malloc(sizeof(foo));
    myfoo->s = NULL;
    
    return myfoo;
}

void free_foo(struct foo *myfoo){
    free(myfoo->s);
}

The basic structure of the for loop is that given some variables (which depend on the loop index) it computes something and returns the information about foo (then this may be directed to some output or used for other calculations but I wont get into details of that). There are two ways of achieving such an effect, one is via a function that returns struct foo and the other struct foo *. To demonstrate an example (though a stupid one), these could be:

struct foo foo_fun1(int size)
{
    int i;
    struct foo myfoo;
    myfoo.s = calloc(size+1, sizeof(char));
    
    for (i=0; i<size; i++){
        myfoo.s[i] = 'A';
    }
    
    return myfoo;
    
}

struct foo *foo_fun2(int size)
{
    int i;
    struct foo *myfoo = new_foo();
    myfoo->s = calloc(size+1, sizeof(char));
    
    for (i=0; i<size; i++){
        myfoo->s[i] = 'A';
    }
    
    return myfoo;
    
}

They achieve the same effect without any leaks if used as such:

int main() {
    int i;
    
    struct foo myfoo1;
    struct foo *myfoo2 = NULL;
    
    for (i=0; i<10; i++){
        
        myfoo1 = foo_fun1(i);
        myfoo2 = foo_fun2(i);
        
        free_foo(&myfoo1);
        free_foo(myfoo2);
        free(myfoo2);
        
    }
    
    
    return 0;
}

In the more realistic scenario this for loop would be going for possibly couple million times (not with these functions though!) and the created structs could contain multiple different strings of lengths that could be as much as couple hundred chars. My question is style or efficiency wise would one consider one method over the other?

> Which of the following two ways of using C structs in a for loop is preferred? [sic]

Evidently, there are two contrasting alternatives you want to consider:

> one is via a function that returns struct foo and the other struct foo *.

Important characteristics of returning a struct foo include:

• The called function does not incur the cost of allocating space for the structure.

• The structure is copied from called function to the caller. This copying may be costly if the structure is large, but it is pretty cheap if the structure is small.

• The caller does not acquire a duty to free the structure itself (though it may acquire a duty to free its contents, as in the example)

• The lifetime of the object, if any, in which the caller stores the structure data is controlled by the caller.

Important characteristics of returning a struct foo * include:

• The called function (probably) incurs the cost of allocating space for the structure.

• Only a pointer to the structure is copied back to the caller. This is pretty cheap regardless of the size of the structure.

• Presuming that the pointed-to structure is dynamically allocated, as in the example, the caller does acquire a duty to free the structure itself, in addition to any duty it may acquire to free the contents.

• The lifetime of the object in which the structure is stored is controlled by the called function (and presumably it is "allocated" duration, though it does not have to be).

> My question is style or efficiency wise would one consider one method over the other?

Supposing that the example driver code reflects the intended usage, in that the structure objects are not required to live past the end of the loop-body execution in which they are created, I would be inclined to save the cost of allocating and deallocating many struct foo objects, as dynamic memory allocation is relatively expensive. If struct foo is small, then that would mean your first alternative, returning a struct foo. But if struct foo were large, then I would consider using an initialization function instead of an object-creation function:

void foo_fun3(struct foo *the_foo, int size) {
    char *s = malloc(size + 1);

    if (s) {
        memset(s, 'A', size);
        s[size] = '
void foo_fun3(struct foo *the_foo, int size) {
char *s = malloc(size + 1);
if (s) {
memset(s, 'A', size);
s[size] = '\0';
}
the_foo->s = s;  
}
// ...
// usage:
void f(void) {
struct foo a_foo;
struct foo *a_foo_pointer = malloc(sizeof(*a_foo_pointer));
foo_fun3(&a_foo, A_SIZE);
foo_fun3(a_foo_pointer, A_SIZE);
// ...
}
';
    }
    
    the_foo->s = s;  
}

// ...

// usage:
void f(void) {
    struct foo a_foo;
    struct foo *a_foo_pointer = malloc(sizeof(*a_foo_pointer));

    foo_fun3(&a_foo, A_SIZE);
    foo_fun3(a_foo_pointer, A_SIZE);

    // ...
}

This approach has the advantage that the caller controls whether memory allocation for the overall structure is performed, and it avoids the cost of copying a result back from called function to caller.

All three are fine stylistically, according to me, though the structure-return alternative is less used than the other two in my experience. As far as efficiency goes, I'm inclined to think that avoiding dynamic allocation as much as is reasonably possible is likely to be to your advantage performance-wise, but you should always answer performance questions by testing.

And speaking of avoiding dynamic allocation, you should consider whether you can avoid allocating the structure member(s), too. You indeed should be able to do that in the example code if you can place an upper bound on the size of the internal buffer, but there may be additional considerations in a real-world scenario.