Appending character to a string in C with strcat - c++

Question

Hi guys I'm still really confused with pointers and I'm wondering if there's anyways to do the following without having to use sprintf:
char a[100], b[100], c[2];
//Some code that puts a string into a
for(i = 0; i<strlen(a); i++)
{
if(a[i] == 'C')
strcat(b, "b");
else if(a[i] == 'O')
strcat(b, "a");
else if(a[i] == 'D')
strcat(b, "1");
else
{
sprintf(c, "%s", a[i]);
strcat(b, c);
}
}
pretty much a for loop looping through a string(an array) and filling up another string with a character(or string) depending on what the character is, if the character ain'T C, O or D it just adds it to the other string.
I can't seem to just do strcat(b, a[i]); and I understand that it wouldn't work because it would try strcat(char *, char) instead of char*, const char*).
Is there anyway I can turn it into a pointer? they still confuse me so much..and I'm new to programming in general just to low level languages...
also what would be the best way to initialize char[]s? that are gonna be filled with a string, what I use right now is :
char ie[30] = ""
Also let me know if there's any easier way to do what
I want and sorry if it's unclear this is obviously a throwaway script but the same concept is used in my script.
Thank you in advance stackoverflow :X

Answer 1

(1) One bug may be in your code:
You are commenting that Some code that puts a string into a, and I think you don't assign any string to b. so by default char b[100]; have garbage value (may not present \0 in b). but string concatenation function expects that b must be a string. So
strcat(b, "b"); <--will Undefined Behavior
(2) A technique to initialize empty string:
Yes you should always initialize you variable (array) with default values like:
char a[100] = {0}, b[100] = {0}, c[2] = {0};
note: remaining elements of a half initialize array would be 0 (null), Initialize a variable assume to be good practice
(3) Yes strcat(b, a[i]); is wrong:
To concatenate string from a[i] on words into b you can do like:
strcat(b, a + i);
yes you are correct strcat(b, a[i]); is not valid indeed.
note: a[i] and (a + i) are not same, a[i] is char type, where as (a + i) is string that is type of a.
Suppose you have following string array a and value of i is 2 then:
+----+----+----+---+---+----+----+----+---+
| 'u'| 's' |'e'|'r'|'5'| '6'| '7'|'8' | 0 |
+----+----+----+---+---+----+----+----+---+
201 202 203 204 205 206 207 208 209 210 211
^ ^
| |
a (a+i)
So in above diagram a values is 201 and type is char [100] (assuming array is 100 in size) (a + i) also points a string from 'e' at address 203. where as a[i] = 'e'
So you can't do strcat(b, a[i]); but strcat(b, a + i); is valid syntax.
Additionally, From #BenVoigt to concat n chars from a from ith position you can do like:
strncat(b, a+i, n);
its will append n char from a+i to b.

Answer 2

Since you want to take a substring of a exactly one character long:
strncat(b, a+i, 1);

Answer 3

Initialize all char array to null so that no garbage values exists in code.
You are appending to garbaged char array.
char a[100]={0}, b[100]={0}, c[2]={0};
Now strcat() function behaves properly.

Answer 4

You seem to be confused in regards to strings. A string isn't just an array. Which book are you reading?
When you first call strcat to operate on b, b isn't guaranteed to be a string. The result is undefined behaviour. This code might seem to function correctly on your system, but if it does then that is by coincidence. I have seen code like this fail in strange ways on other systems. Fix it like this:
char a[100], b[100];
//Some code that puts a string into a
a[x] = '\0'; // <--- Null terminator is required for a to contain a "string".
// Otherwise, you can't pass a to strlen.
for(i = 0; i<strlen(a); i++)
{
if(a[i] == 'C')
b[i] = 'b';
else if(a[i] == 'O')
b[i] = 'a';
else if(a[i] == 'D')
b[i] = '1';
else
b[i] = a[i];
}
b[i] = '\0'; // If you don't put a null character at the end, it isn't a string.
Now, what is a string?

Answer 5

There are many possible ways to do as you wish. There are ways that avoid using strcat() and sprintf() altogether — see below; you can avoid sprintf() while continuing to use strcat().
The way I'd probably do it would keep a record of where the next character is to be added to the target string, b. This will be more efficient since repeatedly using strcat() involves quadratic behaviour as you build up a string one character at a time. Also, it is generally best to avoid using strlen() in the loop condition for the same reason; it is (probably) evaluated on each iteration, so that it too leads to quadratic behaviour.
char a[100], b[100];
char *bp = b;
//Some code that puts a string into a
size_t len = strlen(a);
for (int i = 0; i < len; i++, bp++)
{
if (a[i] == 'C')
*bp = 'b';
else if(a[i] == 'O')
*bp = 'a';
else if(a[i] == 'D')
*bp = '1';
else
*bp = a[i];
}
*bp = '\0'; // Null-terminate the string
You could also do without the pointer by using the index variable i to assign to b (as long as you only add one character to the output for each input character):
char a[100], b[100];
//Some code that puts a string into a
size_t len = strlen(a);
for (int i = 0; i < len; i++)
{
if (a[i] == 'C')
b[i] = 'b';
else if(a[i] == 'O')
b[i] = 'a';
else if(a[i] == 'D')
b[i] = '1';
else
b[i] = a[i];
}
b[i] = '\0'; // Null-terminate the string
As long as the string in a is short enough to fit, the code shown (either version) cannot overflow b. If you sometimes added several characters to b, you'd either need to indexes (i and j), or you could increment the pointer bp in the first version more than once per loop, and you'd need to ensure that you don't overflow the bounds of b.