Clear char array in C without any standard library

Question

I'm working on a class project that would require me to make unique strings and I want to concatenate a number to a string. However I do NOT have access to C Standard Library (memset, malloc, etc.). I made this which works:

char* concat(char* name, int num) {
  int i, j;
  char newName[50], stack[5];

  for(i=0; name[i]!='\0'; ++i) {
    newName[i] = name[i];
  }

  for (j=0; num>=1 || num==0; j++) {
    stack[j] = (num % 10) + '0';
    num = num / 10;
    if (num==0) break;
  }

  while (j>=0) {
    newName[i++] = stack[j--];
  }
  name[0] = '\0';

  return newName;
}

But then as I tested it with multiple strings, I realized that newName was being reused over and over. For ex. This test file outputs the following:

int main() {

  char* rebecca = concat("rebecca", 1);
  char* bill = concat("bill", 2);

  Write(rebecca);  /* bill2ca1 */
  Write(bill);     /* bill2ca1 */
}

It successfully appends the 1 to rebecca, but then when I call concat on bill, it overwrites the first 5 letter but keeps the same chars from before in newName. QUESTION: How to clear a char array so the next time it's called it will be set to empty, or dynamically allocate it (without using C Standard Library)?

Answer 1

Without using malloc, you can simply put the memory on the stack of the calling function, to keep in the scope where it is needed. It's easier to add the buffer pointer to the argument list like so:

char* concat(char *newName, char* name, int num) {
  int i, j;
  char stack[5];
   :
   :
}

int main() {
  char rebecca[50];
  char bill[50];

  concat(rebecca, "rebecca", 1);
  concat(bill, "bill", 2);

  write(rebecca);
  write(bill);
}

Generally speaking, assign memory where it will be used. Embedded programming (which might need to run for months without a reboot) avoids malloc like the plague, just because of the risk of memory leaks. You then need to assign extra space since you may not know the size at compile time, and then ideally check for running past the end of the buffer. Here we know the string sizes and 50 chars is more than enough.

Edit: The other issue is that you're not null terminating. The print will go until it hits 0x00. Your line

name[0] = '\0';

should be

newName[i] = '\0';

Answer 2

You've got a major issue that you're overlooking. In your function, newName is a local variable (array) and you're returning it from the function. This invokes undefined behavior. The beauty of UB is that, sometime it appears to work as expected.

You need to take a pointer and allocate memory dynamically instead, if you want to return it from your concat() function. Also, in the main(), after using it, you need to free() it.

A better alternative, maybe, if you choose to do so, is

1. Define the array in the caller.
2. Pass the array to the function.
3. Inside the function, memset() the array before you perform any other operation.

One thing to remember, this way, every call to the function will clean the previous result.

---

EDIT:

If you cannot use memset(), in the main, you can use a for loop like

for (i = 0; i < sizeof(arr)/sizeof(arr[0]); i++)
    arr[i] = 0;

to clear the array before passing it on next time.

Answer 3

You're returning the address of a local variable. Since the variable goes out of scope when the function returns, this invokes undefined behavior.

You function should dynamically allocate memory for the result of the concatenation, then return that buffer. You'll need to be sure to free that buffer later to prevent a memory leak:

char* concat(char* name, int num) {
  int i, j;
  char *newName, stack[5];
  // allocate enough space for the existing string and digits for a 64-bit number
  newName = malloc(strlen(name) + 30);

  for(i=0; name[i]!='\0'; ++i) {
    newName[i] = name[i];
  }

  for (j=0; num>=1 || num==0; j++) {
    stack[j] = (num % 10) + '0';
    num = num / 10;
    if (num==0) break;
  }

  while (j>=0) {
    newName[i++] = stack[j--];
  }
  newName[i] = '\0';

  return newName;
}

int main() {

  char* rebecca = concat("rebecca", 1);
  char* bill = concat("bill", 2);

  Write(rebecca);
  Write(bill);

  free(rebecca);
  free(bill);
}