No, you're not allocating memory for y->x twice.

Instead, you're allocating memory for the structure (which includes a pointer) plus something for that pointer to point to.

Think of it this way:

         1          2
        +-----+    +------+
y------>|  x------>|  *x  |
        |  n  |    +------+
        +-----+

You actually need the two allocations (1 and 2) to store everything you need.

Additionally, your type should be struct Vector *y since it's a pointer, and you should never cast the return value from malloc in C.

It can hide certain problems you don't want hidden, and C is perfectly capable of implicitly converting the void* return value to any other pointer.

And, of course, you probably want to encapsulate the creation of these vectors to make management of them easier, such as with having the following in a header file vector.h:

#include <stddef.h>

struct Vector {
    double *data;    // Use readable names rather than x/n.
    size_t size;
};

struct Vector *newVector(size_t sz);
void delVector(struct Vector *vector);
//void setVectorItem(struct Vector *vector, size_t idx, double val);
//double getVectorItem(struct Vector *vector, size_t idx);

Then, in vector.c, you have the actual functions for managing the vectors:

#include <stdlib.h>
#include "vector.h"

// Atomically allocate a two-layer object. Either both layers
// are allocated or neither is, simplifying memory checking.

struct Vector *newVector(size_t sz) {
    // First, the vector layer.

    struct Vector *vector = malloc(sizeof (struct Vector));
    if (vector == NULL)
        return NULL;

    // Then data layer, freeing vector layer if fail.

    vector->data = malloc(sz * sizeof (double));
    if (vector->data == NULL) {
        free(vector);
        return NULL;
    }

    // Here, both layers worked. Set size and return.

    vector->size = sz;
    return vector;
}

void delVector(struct Vector *vector) {
    // Can safely assume vector is NULL or fully built.

    if (vector != NULL) {
        free(vector->data);
        free(vector);
    }
}

By encapsulating the vector management like that, you ensure that vectors are either fully built or not built at all - there's no chance of them being half-built.

It also allows you to totally change the underlying data structures in future without affecting clients. For example:

• if you wanted to make them sparse arrays to trade off space for speed.
• if you wanted the data saved to persistent storage whenever changed.
• if you wished to ensure all vector elements were initialised to zero.
• if you wanted to separate the vector size from the vector capacity for efficiency⁽¹⁾.

You could also add more functionality such as safely setting or getting vector values (see commented code in the header), as the need arises.

For example, you could (as one option) silently ignore setting values outside the valid range and return zero if getting those values. Or you could raise an error of some description, or attempt to automatically expand the vector under the covers⁽¹⁾.

In terms of using the vectors, a simple example is something like the following (very basic) main.c

#include "vector.h"

int main(void) {
    struct Vector *myvec = newVector(42);
    myvec->data[0] = 2.718281828459;
    delVector(myvec);
}

⁽¹⁾ That potential for an expandable vector bears further explanation.

Many vector implementations separate capacity from size. The former is how many elements you can use before a re-allocation is needed, the latter is the actual vector size (always <= the capacity).

When expanding, you want to generally expand in such a way that you're not doing it a lot, since it can be an expensive operation. For example, you could add 5% more than was strictly necessary so that, in a loop continuously adding one element, it doesn't have to re-allocate for every single item.

My favorite:

#include <stdlib.h>

struct st *x = malloc(sizeof *x); 

Note that:

• x must be a pointer
• no cast is required
• include appropriate header

You are allocating only memory for the structure itself. This includes the pointer to char, which is only 4 bytes on 32bit system, because it is part of the structure. It does NOT include memory for an unknown length of string, so if you want to have a string, you must manually allocate memory for that as well. If you are just copying a string, you can use strdup() which allocates and copies the string. You must still free the memory yourself though.

 mystruct* structptr = malloc(sizeof(mystruct));
 structptr->word = malloc(mystringlength+1);

 ....

 free(structptr->word);
 free(structptr);

If you don't want to allocate memory for the string yourself, your only choice is to declare a fixed length array in your struct. Then it will be part of the structure, and sizeof(mystruct) will include it. If this is applicable or not, depends on your design though.

It seems, nr is an array of int and not just int. Fix it's declaration:

typedef struct {
    int * nr;
    char *nume, **mesaj;
} utilizator;

If you only want one int, don't call malloc. It will be allocated as part of your utilizator object (funny word btw).

Let's take it apart. Look at the comments

struct node{
    int d;
    struct node * next;   
};

int main(){
    struct node * l = 0;     // Now l = 0 (or NULL)
    struct node * k = l;     // Now k=l=0
    k = malloc(sizeof(struct node));   // Now k=<some address allocated>
    /*
    l->d = 8;                          // But l is still 0
    */
    return 0;
}

So the commented code is trying to dereference a NULL pointer.

What you have created in your example is an array of particle, and another array of pointers to particle. Your first loop fills data into both arrays so that the pointer located in pp[i] points to the particle in list[i].

If your question means "should I always allocate memory to accommodate a pointer to a struct" means "should I always run malloc to make space for every struct pointer I create," the answer is "no," as your code demonstrates. A non-NULL pointer should point to some valid memory space. Very often, you allocate new space immediately by calling malloc. But you can also make the pointer point to space that already exists and is in use. In your case, space from your first array, which is now effectively shared.

Make sure when you run free, you send it exactly the values you got from malloc, exactly one free for each malloc.

In either case, be careful and draw yourself a picture of it so you know what's going on.

struct c c1;
c1.name = "Ana";

You don't have allocate memory here because you are making the pointer c1.name point to a string literal and string literals have static storage duration. This is NOT similar to:

char name[] = "Anna";

Because in this case memory is allocated to store the sting literal and then the string literal "Anna" is copied into the array name . What you do with the struct assignment c1.name = "Ana" is similar to when you do:

char *name = "Anna";

i.e. make the pointer point to a string literal.

If you insist on passing the pointer, it should be by reference, so it's a pointer to a pointer, as the function itslef will modify the address in the pointer.

You're much better off if your function returns a pointer.

//function for allocating the memory
myName *structMemInit(void)
{
    myName *myNameIs = (myName *)calloc(1, sizeof(myName));
    if (myNameIs == NULL) {
        printf("allocating memory didn't work!\n");
        exit(1);
    } else {                     // don't repeat the negation of the condition
        myNameIs->name = "Zach"; // No need for \0, it's automatic
        return myNameIs;
    }
}

//Usage
myName *myNameIs = structMemInit();

BTW it's int main(void) not int main().

To dynamically allocate memory for a struct, the following can be used:

TCarro *carVariable=malloc(sizeof(TCarro)*someNumbers);

, where someNumbers are the number of elements you want to allocate.

From the error you posted in the comment, I assume you tried doing something like:

printf("%d",carVariable);

As you have specified the integer specifier in printf (%d), the compiler expects the function to receive an integer, but you give it a struct TCarro instead.

So now you may be wondering, what specifier can I use to print my carVariable?

C, actually, does not offer such specifier, because structs are types created by the programmer, so it has no idea of how to print it.

What you could do, if you wanted to print your variable would be to print each individual elements of the array.

Something like this:

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

typedef struct{
  char nome[20];
  char placaDoCarro[5];
}TCarro;

int main(void){
  size_t someNumbers=10; //if you want to allocate 10 cars
  TCarro *carVariable=malloc(sizeof(TCarro)*someNumbers);
  //notice that struct before TCarro is not needed, as you defined it as an existing type (named TCarro)

  strcpy(carVariable[0].nome,"Mercedes");
  strcpy(carVariable[0].placaDoCarro,"xxxx");

  strcpy(carVariable[1].nome,"Ford");
  strcpy(carVariable[1].placaDoCarro,"xxxx");
 
  //printf cars
  printf("%s %s\n",carVariable[0].nome, carVariable[0].placaDoCarro);
  printf("%s %s\n",carVariable[1].nome, carVariable[1].placaDoCarro);

  free(carVariable);
  return 0;
}

Notice that I used strcpy, because I needed to copy a string to each field of the struct.