Need some help with dynamic structures

[Space_Shift]

Hello everyone!

 

So, in this moment i'm doing some exercises from my Programming class and we are in structures in C language, in one of the exercises i need to make a dynamic structure (i decided to use two chars and one int at the moment) of any size and then with a menu select if we like to delete the last registry or add another one in the last position. I understand well how dynamic memory works but having it on structures make it's more confusing.

 

At the moment i have some troubles when deleting the last registry from the array.

 

Here's the code from the function, at the moment i'm doing the delete option first

 

Any help i would appreciate it  Thanks.

void changeInfo(automobile ***car){
    int option;
    printf("\nDo you want to make a change to the list? add(2), delete(1)? nothing(0)?\n\n");
    scanf("%d",&option);
    switch(option){
    case 0:
        exit(0);
    break;
    case 1:
    free((*car)[3]->brand);
    free((*car)[3]->model);
    free((*car)[3]->year); //im having some problems with this line//
    *car2=(automobile**)realloc(*car,1*sizeof(automobile*));
    for(int i=0;i<2;i++){
        printf("\nThe registry %d is: Brand %s model %s from year %d",i+1,car[i]->brand,car[i]->model,car[i]->year);
    }
}
    break;
    case 2:
	//will add this later//
    break;
    }
}

 

[Unimportant]

Beeing a 3-star programmer in C is not a compliment

automobile ***car

That construct is never needed. Eighter you pass a pointer (*) if you want to modify what is beeing pointed to, or a pointer to a pointer (**) if you want to modify the pointer itself, more is never needed.

 

You're supposed to allocate dynamic memory for the entire struct, not each member individually. So you get something like this:

struct car
{
	char brand[30];
	char model[30];
	int year;
};

To allocate a car:

struct car NewCar = malloc(sizeof(struct car));

And it will allocate memory for the entire structure, to delete:

free (NewCar);

And it will delete the entire structure, no need to delete each member seperately.

[Hamosch]

A good rule of thumb is that you only ever need to free() memory you have allocated yourself ie. calloc(), malloc()...

 

Anything else will be on the stack or "inside" other heap-memory (as is the case in your case, like @Unimportant showed and explained)

 

allocs [ calloc(), malloc()... ] and frees [ free() ] come in pairs.

[Space_Shift]

Thanks for your replies.

I send a question to my teacher and he said to me that i can put a (***) to modify directly the content without making any auxiliary array. 

 

By far i only want to delete the last registry from the list and in the other case to add a 4th registry in the last position. I made some changes and i have this:

 

Case 1 is for delete and Case 2 is for add another registry

 

void cambiaInfo(automovil ***carro){
    int modificar;
    printf("\nDesea realizar algun cambio de informacion? agregar(2), eliminar(1)? o nada(0)?");
    scanf("%d",&modificar);
    switch(modificar){
    case 0:
        exit(0);
    break;
    case 1:
    free((*carro)[2]->marca);
    free((*carro)[2]->modelo);
    free((*carro)[2]->annio);
    *carro=(automovil**)realloc(*carro,2*sizeof(automovil*));
    for(int i=0;i<2;i++){
    	printf("\nEl registro %d es: Marca %s modelo %s del año %d",i+1,(*carro)[i]->marca,(*carro)[i]->modelo,(*carro)[i]->annio);
    }
    for(int i=0;i<2;i++){
    	free(carro[i]);
	}
	free(carro);
    break;
    case 2:
    (*carro)[4]->marca=malloc(20);
    (*carro)[4]->modelo=malloc(20);
    (*carro)[4]->annio=malloc(4);
    *carro[4]=(automovil*)realloc(*carro,4*sizeof(automovil*));
        (*carro)[4]->marca=(char*)malloc(sizeof(char));
        printf("Marca del auto que desea comprar: ");
        gets((*carro)[4]->marca);
        fflush(stdin);
        (*carro)[4]->modelo=(char*)malloc(sizeof(automovil));
        printf("\nEl modelo del auto: ");
        gets((*carro)[4]->modelo);
        fflush(stdin);
        (*carro)[4]->annio=(int*)malloc(sizeof(automovil));
        printf("\nAño del auto: ");
        scanf("%d",(*carro)[4]->annio);
        fflush(stdin);
    for(int i=0;i<4;i++){
    	printf("\nEl registro %d es: Marca %s modelo %s del año %d",i+1,(*carro)[i]->marca,(*carro)[i]->modelo,(*carro)[i]->annio);
    }
    for(int i=0;i<2;i++){
    	free(carro[i]);
	}
	free(carro);
    break;
    }
}

Sorry for some functions and variables being in spanish , but is the same idea from in the original post.

[Nineshadow]

I don't quite understand what you are trying to do.

Are you trying to implement a stack?

[Space_Shift]

What i'm trying to do is this:

I have a structure with 3 members (char *brand, char *model and int year), then i want to capture 3 items.

For example:

Brand: Ford

Model: Mustang

Year: 2010

----

Brand: Honda

Model: Civic

Year: 2011

----

Brand: VW

Model: Jetta

Year: 2010

 

Then it's going to appear a menu that says if the user want to delete an item or add or exit. If the user choose to delete, it's going to only erase the 3rd registry and only print the first two.

If the user choose to add then it's going to add a 4th registry and capture the information and then print the four items.

 

Right now i'm having problems in the delete and add part of the exercise

 

[Hamosch]

Could you show your struct and the error message you get? Without the complete code it's hard to do any debugging.

[Space_Shift]

Sure, here's the code. Some functions are in spanish but i made some comments in the code so it could be more easy to understand what it's going on.

 

The compiler doesn't show any warnings or errors but i think i have some troubles when i try to make the memory allocation on the two functions after the switch.

 

Spoiler

#include <stdio.h>
#include <stdlib.h>
typedef struct{
    char *marca; //brand of the car
    char *modelo; //model of the car
    int annio; //year of the car
}automovil;
void asignMemoria(automovil ***carro); //function prototypes
void capturaInfo(automovil **carro);
void imprimeInfo(automovil **carro);
void menu(automovil **carro);
void eliminaRegistro(automovil ***carro);
void agregaRegistro(automovil ***carro);
void freeMem(automovil **carro);
int main(void){
    automovil **carro;
    asignMemoria(&carro);
    capturaInfo(carro);
    imprimeInfo(carro);
    menu(carro);
    eliminaRegistro(&carro);
    agregaRegistro(&carro);
    freeMem(carro);
return 0;
}
void asignMemoria(automovil ***carro){ //memory assign with malloc
 *carro=(automovil**)malloc(3*sizeof(automovil*));
 for(int i=0;i<3;i++){
    (*carro)=(automovil*)malloc(3*sizeof(automovil));
 }
}
void capturaInfo(automovil **carro){ //Here i capture the information
    for(int i=0;i<3;i++){
        carro=(automovil*)malloc(3*sizeof(automovil)); //Brand 
        carro->marca=(char*)malloc(3*sizeof(char));
        printf("Marca del auto que desea comprar: ");
        gets(carro->marca);
        fflush(stdin);
        
        carro->modelo=(char*)malloc(3*sizeof(automovil)); //Model 
        printf("\nEl modelo del auto: ");
        gets(carro->modelo);
        fflush(stdin);
        
        printf("\nAño del automovil: "); //Year of the car 
        scanf("%d",&carro->annio);
        fflush(stdin);
    }
}
void imprimeInfo(automovil **carro){ //Shows the information
    printf("\nLos datos de los automoviles registrados son los siguinetes:\n");
    for(int i=0;i<3;i++){
        printf("\nEl registro %d es: Marca %s modelo %s del año %d",i+1,carro->marca,carro->modelo,carro->annio);
    }
}
void menu(automovil **carro){ //Here the user choose to add(2) or delete(1)
    int modificar;
    printf("\nDesea realizar algun cambio de informacion? agregar(2), eliminar(1)? o nada(0)? ");
    scanf("%d",&modificar);
    switch(modificar){
    case 0:
        exit(0);
    break;
    case 1:
        eliminaRegistro(&carro); //
    break;
    case 2:
        agregaRegistro(&carro);
    break;
    }
}
void eliminaRegistro(automovil ***carro){ //Function to delete the last registry, i think i may have some errors with memory allocation
    free((*carro)[2]->marca);
    free((*carro)[2]->modelo);
    free((*carro)[2]);
    *carro=(automovil**)realloc(*carro,2*sizeof(automovil*));
    for(int i=0;i<2;i++){
        printf("\nEl registro %d es: Marca %s modelo %s del año %d",i+1,(*carro)->marca,(*carro)->modelo,(*carro)->annio);
    }
}
void agregaRegistro(automovil ***carro){ //Adds a registry in the last position, same here, i think i may have some error with the memory allocation
    (*carro)[3]->marca=malloc(20);
    (*carro)[3]->modelo=malloc(20);
    *carro=(automovil**)realloc(carro,4*sizeof(automovil*));
    (*carro)[3]->marca=(char*)malloc(sizeof(char));
    printf("Marca del auto que desea comprar: ");
    gets((*carro)[3]->marca);
    fflush(stdin);
    (*carro)[3]->modelo=(char*)malloc(sizeof(automovil));
    printf("\nEl modelo del auto: ");
    gets((*carro)[3]->modelo);
    fflush(stdin);
    printf("\nAño del auto: ");
    scanf("%d",(*carro)[3]->annio);
    fflush(stdin);
    for(int i=0;i<4;i++){
        printf("\nEl registro %d es: Marca %s modelo %s del año %d",i+1,(*carro)->marca,(*carro)->modelo,(*carro)->annio);
    }
}
void freeMem(automovil **carro){ //Free memory function
    for(int i=0;i<3;i++){
        free(carro);
    }
    free(carro);
}
 

 

[Hamosch]

Do you have any boundaries for the assignment? like use lists, use array etc?

[Hamosch]

3 hours ago, Space_Shift said:

Sure, here's the code. Some functions are in spanish but i made some comments in the code so it could be more easy to understand what it's going on.

 

The compiler doesn't show any warnings or errors but i think i have some troubles when i try to make the memory allocation on the two functions after the switch.

 

  Reveal hidden contents

#include <stdio.h>
#include <stdlib.h>
typedef struct{
    char *marca; //brand of the car
    char *modelo; //model of the car
    int annio; //year of the car
}automovil;
void asignMemoria(automovil ***carro); //function prototypes
void capturaInfo(automovil **carro);
void imprimeInfo(automovil **carro);
void menu(automovil **carro);
void eliminaRegistro(automovil ***carro);
void agregaRegistro(automovil ***carro);
void freeMem(automovil **carro);
int main(void){
    automovil **carro;
    asignMemoria(&carro);
    capturaInfo(carro);
    imprimeInfo(carro);
    menu(carro);
    eliminaRegistro(&carro);
    agregaRegistro(&carro);
    freeMem(carro);
return 0;
}
void asignMemoria(automovil ***carro){ //memory assign with malloc
 *carro=(automovil**)malloc(3*sizeof(automovil*));
 for(int i=0;i<3;i++){
    (*carro)=(automovil*)malloc(3*sizeof(automovil));
 }
}
void capturaInfo(automovil **carro){ //Here i capture the information
    for(int i=0;i<3;i++){
        carro=(automovil*)malloc(3*sizeof(automovil)); //Brand 
        carro->marca=(char*)malloc(3*sizeof(char));
        printf("Marca del auto que desea comprar: ");
        gets(carro->marca);
        fflush(stdin);
        
        carro->modelo=(char*)malloc(3*sizeof(automovil)); //Model 
        printf("\nEl modelo del auto: ");
        gets(carro->modelo);
        fflush(stdin);
        
        printf("\nAño del automovil: "); //Year of the car 
        scanf("%d",&carro->annio);
        fflush(stdin);
    }
}
void imprimeInfo(automovil **carro){ //Shows the information
    printf("\nLos datos de los automoviles registrados son los siguinetes:\n");
    for(int i=0;i<3;i++){
        printf("\nEl registro %d es: Marca %s modelo %s del año %d",i+1,carro->marca,carro->modelo,carro->annio);
    }
}
void menu(automovil **carro){ //Here the user choose to add(2) or delete(1)
    int modificar;
    printf("\nDesea realizar algun cambio de informacion? agregar(2), eliminar(1)? o nada(0)? ");
    scanf("%d",&modificar);
    switch(modificar){
    case 0:
        exit(0);
    break;
    case 1:
        eliminaRegistro(&carro); //
    break;
    case 2:
        agregaRegistro(&carro);
    break;
    }
}
void eliminaRegistro(automovil ***carro){ //Function to delete the last registry, i think i may have some errors with memory allocation
    free((*carro)[2]->marca);
    free((*carro)[2]->modelo);
    free((*carro)[2]);
    *carro=(automovil**)realloc(*carro,2*sizeof(automovil*));
    for(int i=0;i<2;i++){
        printf("\nEl registro %d es: Marca %s modelo %s del año %d",i+1,(*carro)->marca,(*carro)->modelo,(*carro)->annio);
    }
}
void agregaRegistro(automovil ***carro){ //Adds a registry in the last position, same here, i think i may have some error with the memory allocation
    (*carro)[3]->marca=malloc(20);
    (*carro)[3]->modelo=malloc(20);
    *carro=(automovil**)realloc(carro,4*sizeof(automovil*));
    (*carro)[3]->marca=(char*)malloc(sizeof(char));
    printf("Marca del auto que desea comprar: ");
    gets((*carro)[3]->marca);
    fflush(stdin);
    (*carro)[3]->modelo=(char*)malloc(sizeof(automovil));
    printf("\nEl modelo del auto: ");
    gets((*carro)[3]->modelo);
    fflush(stdin);
    printf("\nAño del auto: ");
    scanf("%d",(*carro)[3]->annio);
    fflush(stdin);
    for(int i=0;i<4;i++){
        printf("\nEl registro %d es: Marca %s modelo %s del año %d",i+1,(*carro)->marca,(*carro)->modelo,(*carro)->annio);
    }
}
void freeMem(automovil **carro){ //Free memory function
    for(int i=0;i<3;i++){
        free(carro);
    }
    free(carro);
}
 

 

I've just made a basic structure with a list now that works, there's no error checking or user input protection, you should do that yourself but at least you can get some inspiration.

 

I used an exercise from c.learncodethehardway as a skeleton.

 

Don't kill me over this, I just threw it together in a hurry, it'll break if you look at it from the wrong angle but should should server as inspiration

list.c

list.h

Makefile

 

Also don't use scanf (it's made to break), I didn't exchange it for anything as you used it but you should really look into more robust input handling

[Nineshadow]

You can make the stack either with a simple array, which is quite a bit simpler, or with dynamic allocation. And since making a dynamic structure is what you're trying to achieve, we'll go with that.

 

You can imagine a stack as, well, as a stack. You can add something on top of it, you can remove the thing on top of it.

Note: I'll be using C++'s new and delete operators. They are the same thing as malloc and free though (iirc in some compilers new and delete are just wrappers). In simple C there should also be some typedefs around there.

Let's first consider

struct car{
	char *brand;
	char *model;
	int year;
}

 

We'll implement our stack using the same technique as in linked lists.

We'll make a node structure to hold our data and a pointer to the next node:

struct node{
	car data;
	node *next;
};

The next pointer will be null if it's at the end of the queue.

 

Your queue will hold a pointer to its top and update it whenever is the case.

node *top;

Initially, there will be no elements in the queue. We could also keep track of the number of cars in it, but it's not needed.

void init()
{
top=NULL;
}

Now let's get to the function which adds a car into the queue. There will be a new node created with a pointer towards the current top node. Then the top pointer becomes the pointer of the node we've just added.

void push(car c)
{
	node *n = new node;
	n->data=c;
	n->next=top;
	top=n;
}

To remove the top element, we'd do something like this :

void pop()
{
	node *tmp = top;
	top=top->next;
	delete tmp;
}

Of course we can't remove an element if there's none in the queue, but that's error checking.

To access the top car:

car top()
{
	return top->data;
}

 

[Hamosch]

The stack approach from @Nineshadow might be a better idea if the plan isn't to extend the functionality into what a list provides, ie. freely adding and removing elements, etc.

[Unimportant]

This is my little stab at it.

Important note! This code does NOT test if memory allocation succeeded and does not sanitize the input (you can enter nonesense for year, for example). As i find such error handling code obscures what we're trying to do.

 

Also, C99 code, you might have to activate C99 on your compiler, for example gcc requires the command line option '-std=c99'

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

struct Car_s
{
	char		*pBrand;
	char		*pModel;
	int 		Year;
	struct 	Car_s	*pNext;		//Pointer to next car, null if this is last car.
}	*pCarListHead = NULL;

void
AddCar(const char *pBrand, const char *pModel, int Year)
{
	//Allocate memory for the struct and each of the string members based on source string length.
	struct Car_s *pTempCar = malloc(sizeof(struct Car_s));
	pTempCar->pBrand = malloc(strlen(pBrand) * sizeof(char));
	pTempCar->pModel = malloc(strlen(pModel) * sizeof(char));
	
	//Copy data.
	strcpy(pTempCar->pBrand, pBrand);
	strcpy(pTempCar->pModel, pModel);
	pTempCar->Year = Year;

	//Set next member to NULL because this is going to be the new last car.
	pTempCar->pNext = NULL;

	//If list is empty, store as head, otherwise search for last car and append list.
	if (!pCarListHead)
	{
		pCarListHead = pTempCar;
	}
	else
	{
		struct Car_s *pLastCar = pCarListHead;
		while (pLastCar->pNext)
		{
			pLastCar = pLastCar->pNext;
		}
		pLastCar->pNext = pTempCar;
	}
}

void
DeleteLastCar(void)
{
	if (!pCarListHead)
	{
		//No items in list - nothing to delete.
		return;
	}

	bool IsHead = true;
	struct Car_s *pCurrentCar = pCarListHead;
	struct Car_s *pPrevCar = pCarListHead;

	//Search for last car but keep track of the previous item so we can nullify it's next pointer.
	while (pCurrentCar->pNext)
	{		
		IsHead = false;					
		pPrevCar = pCurrentCar;				
		pCurrentCar = pCurrentCar->pNext;
	}

	//pCurrentCar now holds the last car and pPrevCar holds the second to last.
	//Delete string members...
	free(pCurrentCar->pBrand);
	free(pCurrentCar->pModel);

	//Delete the struct itself.
	free(pCurrentCar);

	//If the deleted car was the list head, set head to null, otherwise set the 
	//second to last car's (now becoming last) next pointer to null.
	if (IsHead)
	{
		pCarListHead = NULL;
	}
	else
	{	
		pPrevCar->pNext = NULL;
	}
}

void
DeleteList(void)
{
	//Deletes the entire list.
	while (pCarListHead)
		DeleteLastCar();	
}

void
PrintCars(void)
{
	//Run trough the list front to back and print contents.
	if (!pCarListHead)
	{
		//No items in list - nothing to print.
		printf("List empty :(\n");
		return;
	}
	
	struct Car_s *pCurrentCar = pCarListHead;
	while (pCurrentCar)
	{
		printf("Brand: %s", pCurrentCar->pBrand);
		printf("Model: %s", pCurrentCar->pModel);
		printf("Year : %d\n", pCurrentCar->Year);
		printf("--------------------\n");

		pCurrentCar = pCurrentCar->pNext;
	}
}

void
UserEnterCar(void)
{
	char Brand[50];
	char Model[50];
	int Year;
	//Ask user for a brand, model and year and add to list.
	printf("Enter a car brand: ");
	fgets(Brand, sizeof(Brand), stdin);

	printf("Enter a car model: ");
	fgets(Model, sizeof(Model), stdin);

	printf("Enter year: ");
	scanf("%d", &Year);
	getchar();

	AddCar(Brand, Model, Year);
}

bool
UserMenu(void)
{
	while (1)
	{
		printf("\n1) Delete last entry.");
		printf("\n2) Add new entry.");
		printf("\n3) Exit.\n");

		int Answer;
		scanf("%d", &Answer);
		getchar();

		switch(Answer)
		{
			case 1:		DeleteLastCar(); 	return true;
			case 2: 	UserEnterCar();		return true;	
			case 3:					return false;
			default:	printf("Invalid entry\n"); break;
		}
	}
}

int 
main(void)
{
	//Get the first 3 cars from user.
	for (int i = 0; i < 3; i++)
	{
		UserEnterCar();
	}
	
	//Main loop
	do
	{
		PrintCars();
	} while (UserMenu());

	DeleteList();

	return 0;
}

 

[Space_Shift]

Hey guys thanks again for your replies !

I'm going to give it a try some of the codes that all of you posted, i really appreaciate the help.

[Space_Shift]

EDIT: I sent a message to my teacher and he told me something i was doing wrong in the memory allocation.

 

Thanks for all your help guys