How to be safe with memory? - c

Question

I would like to actually use this wrapper, but the problem is i don't know if it's very safe, yet.
I have a few simple questions regarding using malloc(), calloc(), and realloc(). Here's what I have so far:
string.h
typedef struct str str; // pointer for encapsulation
string.c
struct str
{
char *buf;
size_t len;
}
Say i have a helper function that simply does this:
str *NEW_STRING()
{
str *temp = calloc(1, sizeof (struct str));
temp->len = 0;
temp->buf = (char *) malloc(1);
return temp;
}
Is this safe? If it is, what would happen if i did something like this:
str *A_STRING = NEW_STRING();
A_STRING = NEW_STRING();
It would call malloc and calloc twice, is that bad? Would an initializer be better?
void str_init(str *A_STRING)
{
if (A_STRING)
{
free(A_STRING);
}
if (A_STRING->buf)
{
free(A_STRING->buf);
}
A_STRING = calloc(1, sizeof (struct str));
A_STRING->buf = (char *) malloc(1);
A_STRING->len = 0;
}
Finally, is this a good way to free memory?
void free_string(str *A_STRING)
{
if (A_STRING->buf)
{
free(A_STRING->buf);
}
else
{
A_STRING->buf = NULL;
}
if (A_STRING)
{
free(A_STRING);
}
else
{
A_STRING = NULL;
}
A_STRING->len = 0;
}
Any additional information would be great if included. I don't want to release anything to the public as if it were a good library, because i am primarily doing this for learning purposes.

Answer 1

Lots of errors:
is this safe? if it is, what would happen if i did something like this:
No.
str *NEW_STRING()
{
str *temp = calloc(1, sizeof (struct str));
// If calloc fails and returns NULL all the code below is invalid and blows the code up.
Next:
it would call malloc and calloc twice, is that bad? would an initializer be better?
You leak memory.
The second call basically generates a new object the old object is lost and leaks.
Problems in str_init
void str_init(str *A_STRING)
{
Is this the first time that his method is called?
If so then A_STRING contains a random value (that you are about to FREE).
This will blow the code up.
if (A_STRING)
{
free(A_STRING);
}
A_STRING is freed (you can now no longer accesses it).
Any code that does so is bad.
if (A_STRING->buf) // Bang blow up code.
{
free(A_STRING->buf);
}
A_STRING = calloc(1, sizeof (struct str));
No checking the result of calloc.
A_STRING->buf = (char *) malloc(1);
A_STRING->len = 0;
}
is this a good way to free memory?
void free_string(str *A_STRING)
{
if (A_STRING->buf)
{
free(A_STRING->buf);
}
else
{
A_STRING->buf = NULL; // Its already NULL pointless work
}
if (A_STRING)
{
free(A_STRING);
}
else
{
A_STRING = NULL; // ITs already NULL pointless work
}
// BANG you just blew up the space shuttle.
A_STRING->len = 0;
}