Memory leak plain c - c

Question

I wrote this code to sort names and the code works but there is always error int he end of the program the eror is: Heap corruption.Can someone please help me to uderstan why it is happening and how to fix it?
My code:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TEMP_SIZE 50
void swap(char *str1, char *str2);
int main(void)
{
int number = 0, i = 0, j = 0;
char** names = 0;
char temp[TEMP_SIZE] = { 0 };
printf("Enter number of friends: ");
scanf("%d", &number);
names = (char**)malloc(number * sizeof(char*));
for (i = 0; i < number; i++)
{
printf("Enter name of friend %d: \n", i + 1);
scanf("%s", temp);
names[i] = (char*)malloc(strlen(temp) * sizeof(char) + 1);
strcpy(names[i], temp, strlen(temp) + 1);
}
for (j = 0; j < number - 1; j++)
{
for (i = 0; i < number - 1; i++)
{
if (strcmp(names[i], names[i + 1]) > 0)
{
swap(names[i + 1], names[i]);
}
}
}
for (i = 0; i < number; i++)
{
printf("Friend %d: %s\n", i + 1, names[i]);
}
for (i = number - 1; i >= 0; i--)
{
free(names[i]);
}
free(names);
getchar();
getchar();
return 0;
}
void swap(char *str1, char *str2)
{
char *temp = 0;
temp = (char *)malloc((strlen(str1) + 1) * sizeof(char));
strcpy(temp, str1);
strcpy(str1, str2);
strcpy(str2, temp);
free(temp);
}
I would be pleased and thankful if you will help me!

Answer 1

When the strings are of different length, the swap function above will overwrite the bounds of the allocated strings, corrupting the heap. You probably just want to swap the pointers stored in the names array indices, rather than overwrite the contents of the allocated string buffers.
You could also just use stdlib qsort to sort the array.

Answer 2

The problem with your swap function is that it expects that both strings have
the same length or that both memory locations are large enough to hold the
strings. Consider this example:
char str1[] = "Hello";
char str2[] = "This is a so much longer string";
swap(str1, str2);
will crash, because str1 is not big enough to store the contents of str2, so
the strcpy calls will write beyond the memory limits, thus you are overflowing
the buffer. This is the problem your are facing.
You have to solutions:
allocate for example 1024 bytes for every name[i], regardless of the length
of the name. We can assume that no name is longer than 1024 characters. (Don't do it, ugly solution).
Instead of swapping the contents, swap the pointers. This is much easier to do
because names is char** and name[i] are char*s, so swapping the pointers
is easy as you don't have to worry about the length of the memory they are
pointing to.
The swap function could look like this
void swap_ptrs(char **x, char **y)
{
char *tmp = *x;
*x = *y;
*y = tmp;
}
and instead of calling
swap(names[i + 1], names[i]);
you call:
swap_ptrs(names + i + 1, names + i);
which will swap the pointers.
edit
I realize that you don't even need the swap_ptrs function for this, you can do it like this:
if (strcmp(names[i], names[i + 1]) > 0)
{
char *tmp = names[i];
names[i] = names[i + 1];
names[i + 1] = tmp;
}
And as jspcal points out, the most elegant and robust solution would be to use use qsort:
int comp(const void *x, const void *y)
{
const char *a = *((const char **) x);
const char *b = *((const char **) y);
return strcmp(a, b);
}
int main(void)
{
...
qsort(names, number, sizeof *names, comp);
...
}