I tried making a simple tic tac toe project, and I am trying to make the AI move to random places, so that the AI just moves into any available place. However, it always makes 2 moves. I am wondering why it always makes 2 moves instead of just 1.
What I mean is, let's say the user inputs 'O' into slot 1,1.
0 1 2
+----+----+----+
0 | | | |
| | | |
+----+----+----+
| | | |
1 | | O | |
+----+----+----+
| | | |
2 | | | |
+---------------
Then the computer moves 2 moves: into slots 1,2 AND 2,0
0 1 2
+----+----+----+
0 | | | |
| | | |
+----+----+----+
| | | |
1 | | O | X |
+----+----+----+
| | | |
2 | X | | |
+---------------
So I'd like to know why this happens?
Here is my code:
void compMove(char board[][columns])
{
int randomNum, randomNum1, i, j;
bool didMove = FALSE;
srand((int)time(NULL)); //Seed the random number generator
randomNum = rand() % 3;
randomNum1 = rand() % 3;
while(board[randomNum][randomNum1] != ' ')
{
randomNum = rand() % 3;
randomNum1 = rand() % 3;
}
for(i = 0; i < 3; i++)
{
for(j = 0; j < 3; j++)
{
if(i == randomNum && j == randomNum1)
{
board[i][j] = 'X';
didMove = TRUE;
break;
}
}
if(didMove == TRUE) break;
}
}
You do not need a loop to set movement on the board.
board[randomNum][randomNum1] = 'X';
is enough to set.
And you probably call this function twice, because function plays only one move.
I suspect your checkWin function is the culprit. Probably has an = somewhere you meant to have an ==. But that's just a guess without seeing it.
Your compMove function is grossly overcomplicated, but not wrong. Here's code that does the same thing:
void compMove(char board[][columns]) {
int row, col;
/* DON'T seed RNG here; do it once in main() */
do {
row = rand() % 3;
col = rand() % 3;
} while (board[row][col] != ' ');
board[row][col] = 'X';
}
Related
The code ran differently than I predicted, I think *(score+i*n+j) is problematic, it could also be a problem elsewhere, I'm not quite sure, but I don't know how to modify it.
#include <stdio.h>
#define STUD 30 // Maximum number of students possible
#define COURSE 5 // The maximum number of possible exam subjects
void Total(int *score, int sum[], float aver[], int m, int n);
void Print(int *score, int sum[], float aver[], int m, int n);
int main(void)
{
int i, j, m, n, score[STUD][COURSE], sum[STUD];
float aver[STUD];
printf("Enter the total number of students and courses:\n");
scanf("%d %d",&m,&n);
printf("Enter score:\n");
for (i = 0; i < m; i++)
{
for (j = 0; j < n; j++)
{
scanf("%d", &score[i][j]);
}
}
Total(*score, sum, aver, m, n);
Print(*score, sum, aver, m, n);
return 0;
}
void Total(int *score, int sum[], float aver[], int m, int n)
{
int i, j;
for (i = 0; i < m; i++)
{
sum[i] = 0;
for (j = 0; j < n; j++)
{
sum[i] = sum[i] + *(score + i * n + j);
}
aver[i] = (float) sum[i] / n;
}
}
void Print(int *score, int sum[], float aver[], int m, int n)
{
int i, j;
printf("Result:\n");
for (i = 0; i < m; i++)
{
for (j = 0; j < n; j++)
{
printf("%4d\t", *(score + i * n + j));
}
printf("%5d\t%6.1f\n", sum[i], aver[i]);
}
}
Example of a program running:
Enter the total number of students and courses:
2 3↙
Enter score:
90↙
95↙
97↙
82↙
73↙
69↙
Result:
90 95 97 282 94.0
82 73 69 224 74.7
Compiling your program yields no warnings or errors. Running it with the sample input you've provided yields:
Enter the total number of students and courses:
2 3
Enter score:
90
95
97
82
73
69
Result:
90 95 97 282 94.0
404780 0 82 404862 134954.0
This is correct for the first set of scores, but not the second. As you intuited, this means your math for accessing the array via pointer math is probably wrong.
Consider what your array actually looks like in memory. You've allocated on the stack an array that looks like:
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
Your example input has filled it like this:
+---+---+---+---+---+
| 90| 95| 97| | |
+---+---+---+---+---+
| 82| 73| 69| | |
+---+---+---+---+---+
...
If you want to access the first element of the second row, you need your offset to be i * 5 rather than i * 3 which is what happens when you use i * n. This 5 we can get from your constant COURSE.
*(score + i * COURSE + j)
When you use a different offset you get data which has not been initialized, which is why you see garbage values. If you initialize all of the values in your array to 0, but leave your code otherwise unchanged, you can see this in action.
int i, j, m, n, score[STUD][COURSE] = {0}, sum[STUD];
Enter the total number of students and courses:
2 3
Enter score:
90
95
97
82
73
69
Result:
90 95 97 282 94.0
0 0 82 82 27.3
As you note, the problem is your array accesses -- you use score[i][j] in main to fill the array and then *(score + i * n + j) in your Total and Print functions to try to access it, and these are different and incompatible. The easiest fix is probably just to fix the declarations of Total and Print to match the score you are using:
void Total(int score[][COURSE], int sum[], float aver[], int m, int n);
void Print(int score[][COURSE], int sum[], float aver[], int m, int n);
Then you can just use score[i][j] in them and everything should work. You would also pass score as just score instead of *score.
Alternately, change the declaration of score to score[STUD*COURSE] and use *(score + i * n + j) (or score[i*n + j]) in main to access it like you do in Total and Print.
OP is unclear why the code uses #defines to define values for rows and columns of the array score, then goes on to use scanf() to enter new values that may or may not conflict with the #defines, or even overflow the array memory. Either method works, but using both together confuse things. Pick one or the other.
Aside: If a dynamic sized array is necessary, then it can be created as a pointer, or pointers to allocated memory, or by use of a VLA
eg: A short example of using user input with dynamic memory allocation to create the array sized to the need of the moment:
Note: following method allows you to use plain array notation to assign values:
score[i][j] = someValue://easy to use and readable
//as opposed to
*(score + i*n + j) = someValue;// cumbersome to use and read
Example:
int student, course;//using descriptive variables
printf("Enter the total number of students and courses:\n");
scanf("%d %d",&student,&course);
int (*score)[course] = create_arr_2d (student, course);
if(score)
{ //use score
...
free(score);
}
Where create_arr_2d(...) is defined:
void * create_arr_2d (size_t x, size_t y)
{
int (*ptr_2)[x] = malloc( sizeof (int *[y]) ); //allocate a true 2D array
if(ptr_2)
{
memset(ptr_2, 0, sizeof **ptr_2);
}
return ptr_2;
}
(credit for method)
Addressing your code as is. First, the following creates variables, but does not initialize any of them:
int i, j, m, n, score[STUD][COURSE], sum[STUD];
float aver[STUD];
To eliminate some of the issues you may be seeing, initialize:
int i=0, j=0, m=0, n=0, score[STUD][COURSE]={{0}}, sum[STUD]={0};
float aver[STUD]={0};
In the function prototype in your given code:
Total(int *score, int sum[], float aver[], int m, int n)
int *score
suggests a pointer to a single dimensional array is being passed, but if it is being used to represent score[STUD][COURSE], then it should be passed as `score[m][n], with the prototype changed as:
Total(int m, int n, int score[m][n], int sum[m], float aver[m]);
Then called as:
Total(STUD, COURSE, score[STUD][COURSE], sum[STUD], aver[STUD]){...}
Note, this arrangement makes use of VLA type function arguemnts
Note also, an array such as: (shortened from your values for easier viewing)
int m = 5;
int n = 4
int array[m][n] = {{0}}
creates a single contiguous block of memory, conceivably looking like this in memory:
`|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|...`
0 5 10 15 20
Where all of the elements can be accessed in a for loop like this:
for(int i=0; i<m; i++
for(int j=0;j<n;j++)
*(array + i*n + j);
...
...
While executing the below code:
int main()
{
int abc[3][3]={0};
for(int *ip=&abc[0][0];ip<=&abc[3][3];ip++)
{
printf("%d \n",*ip);
}
}
Expected result is 9 zeros but it displays 12 data. What might be reason?
If you look at the memory layout of a 3x3 array, it looks like:
[0][0] [1][0] [2][0]
+----+----+----+----+----+----+----+----+----+
| | | | | | | | | |
+----+----+----+----+----+----+----+----+----+
Where is the element [3][3]?
[0][0] [1][0] [2][0] [3][0] [3][3]
+----+----+----+----+----+----+----+----+----+----+----+----+----+
| | | | | | | | | | | | | |
+----+----+----+----+----+----+----+----+----+----+----+----+----+
That explains why you end up accessing 12 elements.
Your code is subject to undefined behavior for accessing the beyond valid indices but that's another issue.
You could use:
for (int *ip = &abc[0][0]; ip <= &abc[2][2]; ip++)
{
printf("%d \n",*ip);
}
However, it is better to access a 2D array as a 2D array.
for (size_t i = 0; i < 3; ++i )
{
for (size_t j = 0; j < 3; ++j )
{
printf("%d \n", abc[i][j]);
}
}
Whenever I run my code I get a message: Segmentation fault: 11
My question is why this message is popping up. I have done some research prior to this and have tried to fix it but I still have the same message pop up. Please review my code!
To give some context to my code: The goal of this program is to implement the Connect Four game between a computer and a human player. Functions are to be implemented in the file connect4_functions.c. Forward declarations of these functions are in the file connect4_functions.h. connect4.c contains the main () functions.
The code (connect4_functions.c) is below:
#include "connect4_functions.h"
int print_welcome(void) // PROBLEM: returnerer alltid 1
{
printf ("*** Welcome to the Connect Four game!!! ***\n");
printf ("Would you like to make the first move [y/n]: ");
if (getchar() == 'N' || getchar() == 'n') return 2;
else return 1;
while (getchar()!= '\n');
}
void display_board(int board[][BOARD_SIZE_VERT])
{
int i, j;
for (i = BOARD_SIZE_VERT-1; i >= 0; i--)
{
for (j = 0; j < BOARD_SIZE_HORIZ; j++) printf ("+---");
printf ("+\n");
for (j = 0; j < BOARD_SIZE_HORIZ; j++)
{
switch (board[j][i])
{
case 0: printf ("| "); break;
case 1: printf ("| O "); break;
case 2: printf ("| X "); break;
}
}
printf ("|\n");
} // end for
for (j = 0; j < BOARD_SIZE_HORIZ; j++) printf ("+---");
printf ("+\n");
for (j = 1; j <= BOARD_SIZE_HORIZ; j++) printf (" %d ", j);
printf ("\n");
} //end function display_board
int random_move(int board[][BOARD_SIZE_VERT], int computer_num)
{
int m = (rand() % BOARD_SIZE_HORIZ) + 1;
if (!is_column_full(board,m))
{
update_board(board,m,computer_num);
return m;
}
else return random_move(board,computer_num);
}
int player_move(int board[][BOARD_SIZE_VERT], int player_num)
{
int m;
printf ("Please enter your move: ");
scanf ("%d", &m);
while (getchar() != '\n');
if ( 0 > m || m > BOARD_SIZE_HORIZ)
{
printf ("Not a valid move. Enter a column number!\n");
return player_move(board, player_num);
}
if (is_column_full(board, m))
{
printf ("This column is full. Try again!\n");
return player_move(board, player_num);
}
update_board(board,m,player_num);
return m;
}
bool check_win_or_tie(int board[][BOARD_SIZE_VERT], int last_move)
{
int m, count = 0;
if (check_winner(board, last_move))
{
printf("Player %c won!\n", ( check_winner(board,last_move) == 1 ? '1' : '2' ) );
return true;
}
for (m = 0; m < BOARD_SIZE_HORIZ; m++) if ( is_column_full(board, m) ) count++;
if (count == BOARD_SIZE_HORIZ)
{
printf ("Tie game!\n");
return true;
}
else return false;
}
bool is_column_full(int board[][BOARD_SIZE_VERT], int m)
{
return (board[m-1][BOARD_SIZE_VERT-1]);
}
void update_board(int board[][BOARD_SIZE_VERT], int m, int player_num)
{
int i;
for ( i = 0; i < BOARD_SIZE_VERT ; i++)
{
if (!board[m-1][i])
{
board[m-1][i] = player_num;
return;
}
}
}
int check_winner(int board[][BOARD_SIZE_VERT], int last_move)
{
int i, row, count;
// Find row
for (row = 0; row < BOARD_SIZE_VERT; row++)
{
if (board[last_move-1][row]) count++;
}
row = count;
printf ("row = %d\n", row);
// Vertical
for (i = 0; i < BOARD_SIZE_VERT; i++)
{
if (board[last_move-1][i] == board[last_move-1][row]) count++;
else count = 0;
if (count == 4) return board[last_move-1][row];
else return 0;
}
count = 0; // reset
// Horizontal
for (i = 0; i < BOARD_SIZE_HORIZ; i++)
{
if (board[i][row] == board[last_move-1][row]) count++;
else count = 0;
if (count == 4) return board[last_move-1][row];
else return 0;
}
count = 0; // reset
return 0;
}
The code for connect4_functions.h (cannot be changed) is below:
#ifndef CONNECT4_FUNCTIONS
#define CONNECT4_FUNCTIONS
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <stdbool.h>
#define BOARD_SIZE_HORIZ 7
#define BOARD_SIZE_VERT 6
int print_welcome(void);
void display_board(int board[][BOARD_SIZE_VERT]);
int random_move(int board[][BOARD_SIZE_VERT], int computer_num);
int player_move(int board[][BOARD_SIZE_VERT], int player_num);
bool check_win_or_tie(int board[][BOARD_SIZE_VERT], int last_move);
bool is_column_full(int board[][BOARD_SIZE_VERT], int m);
void update_board(int board[][BOARD_SIZE_VERT], int m, int player_num);
int check_winner(int board[][BOARD_SIZE_VERT], int last_move);
int best_move(int board[][BOARD_SIZE_VERT], int computer_num);
#endif
The code for connect4.c (also cannot be changed) is below:
#include "connect4_functions.h"
int main()
{
int board[BOARD_SIZE_HORIZ][BOARD_SIZE_VERT] = { {0} };
int player_num, computer_num;
int last_move;
/* Ask Alice if she wants to go first */
player_num = print_welcome();
if (player_num == 1) computer_num = 2;
else computer_num = 1;
/* If Alice wants to go first, let her make a move */
if (player_num == 1)
{
display_board(board);
last_move = player_move(board,player_num);
display_board(board);
}
/* The main loop */
while (1)
{
/* Make a computer move, then display the board */
last_move = random_move(board,computer_num);
printf("Computer moved in column: %d\n", last_move);
display_board(board);
/* Check whether the computer has won */
if (check_win_or_tie(board,last_move)) return 0;
/* Let Alice make a move, then display the board */
last_move = player_move(board,player_num);
display_board(board);
/* Check whether Alice has won */
if (check_win_or_tie(board,last_move)) return 0;
} /* end of while (1) */
} /* end of main() */
Also, if you would like to see the original pdf it is linked below:
Link to pdf
The output is:
*** Welcome to the Connect Four game!!! ***
Would you like to make the first move [y/n]: y
+---+---+---+---+---+---+---+
| | | | | | | |
+---+---+---+---+---+---+---+
| | | | | | | |
+---+---+---+---+---+---+---+
| | | | | | | |
+---+---+---+---+---+---+---+
| | | | | | | |
+---+---+---+---+---+---+---+
| | | | | | | |
+---+---+---+---+---+---+---+
| | | | | | | |
+---+---+---+---+---+---+---+
1 2 3 4 5 6 7
Please enter your move: 4
+---+---+---+---+---+---+---+
| | | | | | | |
+---+---+---+---+---+---+---+
| | | | | | | |
+---+---+---+---+---+---+---+
| | | | | | | |
+---+---+---+---+---+---+---+
| | | | | | | |
+---+---+---+---+---+---+---+
| | | | | | | |
+---+---+---+---+---+---+---+
| | | | O | | | |
+---+---+---+---+---+---+---+
1 2 3 4 5 6 7
Computer moved in column: 1
+---+---+---+---+---+---+---+
| | | | | | | |
+---+---+---+---+---+---+---+
| | | | | | | |
+---+---+---+---+---+---+---+
| | | | | | | |
+---+---+---+---+---+---+---+
| | | | | | | |
+---+---+---+---+---+---+---+
| | | | | | | |
+---+---+---+---+---+---+---+
| X | | | O | | | |
+---+---+---+---+---+---+---+
1 2 3 4 5 6 7
row = -355898527
Segmentation fault: 11
(If you have any questions about the context or purpose please don't hesitate to ask!)
Not having actually run the code, I believe the issue may be that count is not initialized in check_winner:
int check_winner(int board[][BOARD_SIZE_VERT], int last_move)
{
int i, row, count;
// Find row
for (row = 0; row < BOARD_SIZE_VERT; row++)
{
if (board[last_move-1][row]) count++;
}
row = count;
// WHAT IF IT EXITS THE for () WITHOUT board[last_move-1][row] being non-zero?
// HINT: count can be anything!
printf ("row = %d\n", row);
You then use row as an access into an array, and boom! You've accessed memory outside your permissions.
In the check_winner function you don't initialise the variable count. I get an unitialised variable runtime error, yet if I continue ahead a couple of lines later you then set:
row = count;
Which in my case is setting row to -858993459;
A couple of lines down in that same function you write:
if (board[last_move - 1][i] == board[last_move - 1][row]) count++;
// You use "row", an initialised variable as the index
// for the second subscript operator of board.
And that's where I get:
Access violation reading location 0x0000005663E82BB4. occurred
I think there should have been a warning shown about this unitialised variable. And honestly, I don't know if that's all that's wrong with it, but it looks like a pretty good game.
First of all, to be able to solve your problem, you should make sure everything that might be printed before the crash, has been printed. In this goal, you should add a fflush(stdout); instruction after each of your printing instructions
secondly, if this doesn't make clear at what place you program crashes, you should add supplementary tracing instruction inside the piece of code where it happens.
And then, when you have identified which instruction causes de crash, you should print it's variables to check if their values are what you expect.
Alternatively, you can use the assert instruction to make sure the variable values are all in the expected ranges.
I'm working through the K&R C programming book, and I just completed exercise 1-13 where you print a histogram of the lengths of words that are input. My horizontal histogram is fine, but my vertical histogram has a '%' sign appearing at the end of it, and I can't figure out why that keeps happening. Here is the loop that I think is causing the issue:
for (i = 0; i < array_length; i++) {
printf("%-4d", i + 1);
}
If the array_length is 7, I will have a '%' sign after the 7th position like this:
|
| |
| |
| |
| |
| |
| | | | |
| | | | | |
| | | | | | |
| | | | | | |
| | | | | | |
1 2 3 4 5 6 7 %
If I remove this loop, the vertical bars print fine, I just don't get the numbering below each of them.
What is going on here? As far as I can guess, the printf is running one extra time with garbage data in 'i', but I can't figure out why or how this is happening.
I'm compiling with gcc on Ubuntu, if that makes any difference.
Here is the complete code for your reference:
#include <stdio.h>
#define IN 1
#define OUT 0
#define ARRAY_SIZE 1000
int main() {
int c, current_word_length, state, i, j, current_word, largest, array_length, top;
int word_lengths[ARRAY_SIZE];
current_word_length = current_word = largest = 0;
state = OUT;
for (i = 0; i < ARRAY_SIZE; i++) {
word_lengths[i] = 0;
}
printf("Enter up to 1000 words and this program will calculate their length.\n");
printf("Please enter a newline, tab, or space before the last word entered, then EOF to print summary.\n\n");
while ((c = getchar()) != EOF) {
if (c == ' ' || c == '\t' || c == '\n') {
if (state == IN) {
word_lengths[current_word++] = current_word_length;
if (current_word_length > largest) {
largest = current_word_length;
}
current_word_length = 0;
state = OUT;
}
} else {
state = IN;
current_word_length++;
}
}
array_length = current_word;
printf("\nWord Lengths Histogram Horizontal:\n\n");
for (i = 0; i < array_length; i++) {
printf("%-4d: ", i + 1);
for (j = 0; j < word_lengths[i]; j++) {
printf("=");
}
printf("\n");
}
printf("\nWord Lengths Histogram Vertical:\n\n");
top = largest;
while (top > 0) {
for (i = 0; i < array_length; i++) {
if (word_lengths[i] >= top) {
printf("%-4c", '|');
} else {
printf("%-4c", ' ');
}
}
printf("\n");
top--;
}
for (i = 0; i < array_length; i++) {
printf("%-4d", i + 1);
}
return 0;
}
And here is what I expect to occur using this input string "Bacon ipsum dolor amet frankfurter landjaeger ham":
Enter up to 1000 words and this program will calculate their length.
Please enter a newline, tab, or space before the last word entered, then EOF to print summary.
Bacon ipsum dolor amet frankfurter landjaeger ham
Word Lengths Histogram Horizontal:
1 : =====
2 : =====
3 : =====
4 : ====
5 : ===========
6 : ==========
7 : ===
Word Lengths Histogram Vertical:
|
| |
| |
| |
| |
| |
| | | | |
| | | | | |
| | | | | | |
| | | | | | |
| | | | | | |
1 2 3 4 5 6 7
OK, as pointed out by nos and chqrlie in the comments, I need to add a newline at the end of my program so that the shell prompt will appear on a newline AFTER the program has finished running.
Adding the putchar() call at the end of main() fixed my issue:
for (i = 0; i < array_length; i++) {
printf("%-4d", i + 1);
}
putchar('\n');
return 0;
} // end main()
char command [][12] = {
{"Attention!!"},
{"About Turn!"},
{"Left Turn!"},
{"right Turn!"},
{"Dismiss!"}
};
int i;
for (i=1; i<5; i++)
{
strcat (command [0], command [i]);
}
printf ("length of command[0]:%ld\nNew string:%s\n", strlen(command[0]), command[0]);
In the above block of code, do I need to check destination string command[0] to see if it has enough space for the other 4 strings?
I didn't do that but it turns out the compiler didn' t report any error and printed out the concatenated string.
Is it ok to do it like this with a for loop?
Yes, you do need to consider the space available in the target string
when using strcat(). In fact, you need to consider the available
space for all string manipulation operations. If you don't know that
there is enough space, you are not safe.
Consider the array:
char command[][12] =
{
{"Attention!!"},
{"About Turn!"},
{"Left Turn!"},
{"Right Turn!"},
{"Dismiss!"}
};
The memory for the array looks like this, using $ to represent '\0'
+---+---+---+---+---+---+---+---+---+---+---+---+
| A | t | t | e | n | t | i | o | n | ! | ! | $ |
+---+---+---+---+---+---+---+---+---+---+---+---+
| A | b | o | u | t | | T | u | r | n | ! | $ |
+---+---+---+---+---+---+---+---+---+---+---+---+
| L | e | f | t | | T | u | r | n | ! | $ | $ |
+---+---+---+---+---+---+---+---+---+---+---+---+
| R | i | g | h | t | | T | u | r | n | ! | $ |
+---+---+---+---+---+---+---+---+---+---+---+---+
| D | i | s | m | i | s | s | ! | $ | $ | $ | $ |
+---+---+---+---+---+---+---+---+---+---+---+---+
The specification of strcat() says:
The strcat function appends a copy of the string pointed to by s2
(including the terminating null character) to the end of the string
pointed to by s1. The initial character of s2 overwrites the null
character at the end of s1. If copying takes place between objects
that overlap, the behavior is undefined.
Your processing loop is:
for (int i = 1; i < 5; i++)
{
strcat(command[0], command[i]);
}
It is fairly clear that you are invoking undefined behaviour because the
extended material in command[0] runs over the content of command[1].
Nevertheless, some common implementations will actually behave sensibly,
but there is no guarantee that every implementation will.
Indeed, when run on macOS Sierra 10.12.2 with GCC 6.3.0, the first
iteration of the loop generates an Abort trap: 6 error. This is a
perfectly legitimate result of 'undefined behaviour'.
However, if we 'reimplement' strcat() to behave as you might expect,
what you end up with is:
+---+---+---+---+---+---+---+---+---+---+---+---+
| A | t | t | e | n | t | i | o | n | ! | ! | A |
+---+---+---+---+---+---+---+---+---+---+---+---+
| b | o | u | t | | T | u | r | n | ! | L | e |
+---+---+---+---+---+---+---+---+---+---+---+---+
| f | t | | T | u | r | n | ! | R | i | g | h |
+---+---+---+---+---+---+---+---+---+---+---+---+
| t | | T | u | r | n | ! | D | i | s | m | i |
+---+---+---+---+---+---+---+---+---+---+---+---+
| s | s | ! | $ | i | s | s | ! | $ | $ | $ | $ |
+---+---+---+---+---+---+---+---+---+---+---+---+
Demonstration code
#include <ctype.h>
#include <stdio.h>
#include <string.h>
static inline void n_strcat(char *s1, char *s2)
{
memmove(s1 + strlen(s1), s2, strlen(s2) + 1);
}
#ifndef USE_REAL_STRCAT
#undef strcat
#define strcat(s1, s2) n_strcat(s1, s2)
#endif /* USE_REAL_STRCAT */
static void print_bar(int cols)
{
printf(" +");
for (int i = 0; i < cols; i++)
printf("---+");
putchar('\n');
}
static void print_cmd(int rows, int cols, char cmd[rows][cols])
{
print_bar(cols);
for (int i = 0; i < rows; i++)
{
printf(" |");
for (int j = 0; j < cols; j++)
{
unsigned char u = cmd[i][j];
if (!isprint(u))
u = '$';
printf(" %c |", u);
}
putchar('\n');
print_bar(cols);
}
}
int main(void)
{
char command[][12] =
{
{ "Attention!!" },
{ "About Turn!" },
{ "Left Turn!" },
{ "Right Turn!" },
{ "Dismiss!" },
};
enum { CMD_ROWS = sizeof(command) / sizeof(command[0]) };
enum { CMD_COLS = sizeof(command[0]) / sizeof(command[0][0]) };
print_cmd(CMD_ROWS, CMD_COLS, command);
for (int i = 1; i < 5; i++)
strcat(command[0], command[i]);
printf("\nLength of command[0]: %zu\nNew string: [%s]\n\n", strlen(command[0]), command[0]);
print_cmd(CMD_ROWS, CMD_COLS, command);
return 0;
}
The output from the program is the two tables shown above, with this information in between:
Length of command[0]: 51
New string: [Attention!!About Turn!Left Turn!Right Turn!Dismiss!]