Table of Contents

What is strcat()?

The strcat() function in C (string concatenation) is used to append (join) one string to the end of another string. It is part of the <string.h> library.

Function Syntax

char *strcat(char *destination, const char *source);

Parameter	Description
`destination`	The target string where source will be appended
`source`	The string to be appended
Return value	Pointer to the destination string

Basic Usage

#include <stdio.h>
#include <string.h>
int main() {
char dest[50] = "Hello ";
char src[] = "World!";
// Append src to dest
strcat(dest, src);
printf("Result: %s\n", dest);  // Output: Hello World!
return 0;
}

Memory Layout Before and After:

Before:
dest: [H][e][l][l][o][ ][\0][ ][ ][ ]...
src:  [W][o][r][l][d][!][\0]
After strcat():
dest: [H][e][l][l][o][ ][W][o][r][l][d][!][\0]

Multiple Concatenations

#include <stdio.h>
#include <string.h>
int main() {
char result[100] = "I ";
strcat(result, "love ");
strcat(result, "C ");
strcat(result, "programming ");
strcat(result, "language!");
printf("%s\n", result);
// Output: I love C programming language!
return 0;
}

strcat() Return Value

The function returns a pointer to the destination string, allowing chaining.

#include <stdio.h>
#include <string.h>
int main() {
char str[100] = "Hello";
// Chaining strcat calls
char *ptr = strcat(strcat(str, " "), "World");
printf("String: %s\n", str);   // Hello World
printf("Pointer: %s\n", ptr);  // Hello World (same as str)
// Verify they point to same memory
if(ptr == str) {
printf("Returns pointer to destination\n");
}
return 0;
}

Practical Example 1: Building Sentences

#include <stdio.h>
#include <string.h>
int main() {
char sentence[200] = "";
char words[5][20] = {"The", "quick", "brown", "fox", "jumps"};
// Build sentence word by word
for(int i = 0; i < 5; i++) {
strcat(sentence, words[i]);
if(i < 4) {
strcat(sentence, " ");  // Add space between words
}
}
strcat(sentence, "!");
printf("%s\n", sentence);
// Output: The quick brown fox jumps!
return 0;
}

Practical Example 2: Creating Full Path

#include <stdio.h>
#include <string.h>
int main() {
char path[100] = "/home/user/";
char folder[] = "documents/";
char file[] = "notes.txt";
// Build complete file path
strcat(path, folder);
strcat(path, file);
printf("Full path: %s\n", path);
// Output: /home/user/documents/notes.txt
return 0;
}

Practical Example 3: User Input Concatenation

#include <stdio.h>
#include <string.h>
int main() {
char firstName[50];
char lastName[50];
char fullName[100] = "";
printf("Enter first name: ");
scanf("%s", firstName);
printf("Enter last name: ");
scanf("%s", lastName);
// Build full name
strcat(fullName, firstName);
strcat(fullName, " ");
strcat(fullName, lastName);
printf("Full name: %s\n", fullName);
return 0;
}

Important Rules and Warnings

Rule 1: Destination Must Be Large Enough

#include <stdio.h>
#include <string.h>
int main() {
// DANGEROUS: dest too small!
char dest[10] = "Hello";
char src[] = " World!!!";
// This will overflow the buffer (BAD!)
// strcat(dest, src);
// Safe version: Ensure enough space
char safeDest[20] = "Hello";
strcat(safeDest, src);
printf("Safe: %s\n", safeDest);
// Calculate required size
char str1[] = "Hello";
char str2[] = " World";
int requiredSize = strlen(str1) + strlen(str2) + 1;
printf("Need at least %d bytes for both strings + null\n", requiredSize);
return 0;
}

Rule 2: Destination Must Be Null-Terminated

#include <stdio.h>
#include <string.h>
int main() {
char dest[20];
// WRONG: dest not initialized (no null terminator)
// strcat(dest, "Hello");  // DANGEROUS!
// CORRECT: Ensure destination is null-terminated
char correct[20] = "";  // First char is '\0'
strcat(correct, "Hello");
printf("Correct: %s\n", correct);
return 0;
}

Rule 3: Strings Cannot Overlap

#include <stdio.h>
#include <string.h>
int main() {
char str[20] = "Hello";
// WRONG: Source and destination overlap
// strcat(str, str);  // Undefined behavior!
// CORRECT: Use separate strings or copy first
char temp[20];
strcpy(temp, str);
strcat(str, temp);
printf("Safe: %s\n", str);  // HelloHello
return 0;
}

strncat() - Safer Alternative

strncat() allows you to specify the maximum number of characters to append, preventing buffer overflow.

#include <stdio.h>
#include <string.h>
int main() {
char dest[15] = "Hello";
char src[] = " World!!!";  // 9 chars including space and !!!
// Append at most 5 chars from src
strncat(dest, src, 5);  // Appends " Worl"
printf("Result: %s\n", dest);  // Hello Worl
// strncat always adds null terminator
char safe[10] = "Hi";
char longSrc[] = "ThisIsAVeryLongString";
strncat(safe, longSrc, 6);  // Only append 6 chars
printf("Safe: %s\n", safe);  // HiThisIs
return 0;
}

strncat() Syntax

char *strncat(char *dest, const char *src, size_t n);

Parameter	Description
`dest`	Destination string
`src`	Source string
`n`	Maximum number of characters to append
Return	Pointer to destination

Manual Implementation of strcat()

Understanding how strcat works internally:

#include <stdio.h>
char *my_strcat(char *dest, const char *src) {
char *ptr = dest;
// 1. Find the end of destination string
while(*ptr != '\0') {
ptr++;
}
// 2. Copy source characters to destination end
while(*src != '\0') {
*ptr = *src;
ptr++;
src++;
}
// 3. Add null terminator
*ptr = '\0';
return dest;
}
int main() {
char str1[50] = "Hello ";
char str2[] = "World";
my_strcat(str1, str2);
printf("Manual concatenation: %s\n", str1);
// Output: Hello World
return 0;
}

Comparing strcat() with Other Methods

#include <stdio.h>
#include <string.h>
int main() {
// Method 1: strcat()
char str1[50] = "Hello";
strcat(str1, " World");
printf("strcat(): %s\n", str1);
// Method 2: sprintf()
char str2[50] = "Hello";
sprintf(str2, "%s World", str2);
printf("sprintf(): %s\n", str2);
// Method 3: Manual loop
char str3[50] = "Hello";
char *ptr = str3 + strlen(str3);
const char *src = " World";
while(*src) *ptr++ = *src++;
*ptr = '\0';
printf("Manual: %s\n", str3);
// Method 4: strcpy() at end
char str4[50] = "Hello";
strcpy(str4 + strlen(str4), " World");
printf("strcpy(): %s\n", str4);
return 0;
}

Common Use Cases

Building SQL Queries

#include <stdio.h>
#include <string.h>
int main() {
char query[200] = "SELECT * FROM users";
char condition[100] = " WHERE age > 18";
strcat(query, condition);
strcat(query, " ORDER BY name");
printf("SQL Query: %s\n", query);
// Output: SELECT * FROM users WHERE age > 18 ORDER BY name
return 0;
}

Creating Dynamic Messages

#include <stdio.h>
#include <string.h>
int main() {
char username[] = "Alice";
char action[] = "logged in";
char timestamp[] = "10:30 AM";
char logEntry[200] = "[";
strcat(logEntry, timestamp);
strcat(logEntry, "] ");
strcat(logEntry, username);
strcat(logEntry, " ");
strcat(logEntry, action);
printf("Log: %s\n", logEntry);
// Output: [10:30 AM] Alice logged in
return 0;
}

Formatting Output with strcat()

#include <stdio.h>
#include <string.h>
void printBanner(const char *title) {
char banner[100] = "";
strcat(banner, "=");
for(int i = 0; i < strlen(title) + 2; i++) {
strcat(banner, "=");
}
strcat(banner, "=\n");
strcat(banner, "| ");
strcat(banner, title);
strcat(banner, " |\n");
strcat(banner, "=");
for(int i = 0; i < strlen(title) + 2; i++) {
strcat(banner, "=");
}
strcat(banner, "=\n");
printf("%s", banner);
}
int main() {
printBanner("WELCOME");
printBanner("C PROGRAMMING");
return 0;
}

Output:

==========
| WELCOME |
==========
================
| C PROGRAMMING |
================

Performance Considerations

#include <stdio.h>
#include <string.h>
#include <time.h>
int main() {
char buffer[10000] = "";
char add[] = "word";
// Inefficient: Multiple strcat calls in loop
clock_t start = clock();
for(int i = 0; i < 1000; i++) {
strcat(buffer, add);  // Each call scans entire string
}
clock_t end = clock();
printf("Multiple strcat: %ld ms\n", (end - start));
// Efficient: strcpy at current position
char buffer2[10000] = "";
char *ptr = buffer2;
start = clock();
for(int i = 0; i < 1000; i++) {
strcpy(ptr, add);
ptr += strlen(add);  // Move pointer forward
}
end = clock();
printf("Pointer tracking: %ld ms\n", (end - start));
return 0;
}

strcat() vs strncat() Comparison

Feature	strcat()	strncat()
Safety	Unsafe (no bounds check)	Safer (bounds check)
Parameters	2 parameters	3 parameters (adds max length)
Buffer overflow	Possible	Prevented
Performance	Slightly faster	Slightly slower (extra check)
Use case	Known safe sizes	Unknown or variable sizes

#include <stdio.h>
#include <string.h>
int main() {
char buffer[10] = "Hi";
char source[] = "HelloWorld";
// UNSAFE: strcat will overflow
// strcat(buffer, source);  // DANGER!
// SAFE: strncat limits append
strncat(buffer, source, 7);  // Appends "HelloWo" (7 chars)
printf("strncat result: %s\n", buffer);  // HiHelloWo
// strncat always null-terminates
char buffer2[10] = "Hi";
strncat(buffer2, "HelloWorld", 10);  // Appends up to available space
printf("Safe append: %s\n", buffer2);
return 0;
}

Quick Reference

// Basic concatenation
strcat(dest, src);           // Append src to dest
// Safe concatenation
strncat(dest, src, n);       // Append at most n chars
// Chaining
strcat(strcat(dest, "Hello"), " World");
// Check available space
size_t needed = strlen(dest) + strlen(src) + 1;
if(needed <= dest_size) {
strcat(dest, src);
}
// Manual implementation
while(*dest) dest++;   // Find end
while(*src) *dest++ = *src++;  // Copy
*dest = '\0';          // Null terminate

Summary

strcat() appends one string to another
Destination must be large enough to hold both strings + null terminator
Both strings must be null-terminated
Returns pointer to destination (allows chaining)
strncat() is safer for production code
Do NOT use overlapping strings as source and destination
Inefficient in loops (use pointer tracking for multiple concatenations)
Always include <string.h> header file

Complete C Programming Guide + Compilers Collection

1. C srand() Function – Understanding Seed Initialization

https://macronepal.com/understanding-the-c-srand-function
Explains how srand() initializes the pseudo-random number generator in C by setting a seed value. Using the same seed produces the same sequence, while time(NULL) gives different results each run.

2. C rand() Function Mechanics and Limitations

https://macronepal.com/c-rand-function-mechanics-and-limitations
Explains how rand() generates pseudo-random numbers between 0 and RAND_MAX, its deterministic nature, and limitations for security use cases.

3. C log() Function

https://macronepal.com/c-log-function-2
Covers natural logarithm calculation using <math.h> and its applications.

4. Mastering Date and Time in C

https://macronepal.com/mastering-date-and-time-in-c
Explains <time.h> functions like time(), clock(), difftime(), and struct tm.

5. Mastering time_t Type in C

https://macronepal.com/mastering-the-c-time_t-type-for-time-management
Explains time representation as seconds since Unix epoch and conversion functions.

6. C exp() Function

https://macronepal.com/c-exp-function-mechanics-and-implementation
Explains exponential function exp(x) and its scientific applications.

7. C log() Function (Alternate Guide)

https://macronepal.com/c-log-function
Comparison of log() and log10() with usage examples.

8. C log10() Function

https://macronepal.com/mastering-the-log10-function-in-c
Explains base-10 logarithm for engineering and scientific applications.

9. C tan() Function

https://macronepal.com/understanding-the-c-tan-function
Explains tangent function and radian-based calculations.

10. Random Numbers in C (Secure vs Predictable)

https://macronepal.com/mastering-c-random-numbers-for-secure-and-predictable-applications
Explains difference between rand() and secure randomness methods.

11. Free Online C Compiler

https://macronepal.com/free-online-c-code-compiler-2
Browser-based compiler for testing C programs instantly.

C Functions, Arguments, Parameters & Flow

Mastering Functions in C – Complete Guide

https://macronepal.com/c/mastering-functions-in-c-a-complete-guide/
Covers function structure, modular programming, and real-world usage.

Function Arguments in C

https://macronepal.com/c-function-arguments/
Explains how arguments are passed and used in function calls.

Function Parameters in C

https://macronepal.com/c-function-parameters/
Explains defining inputs for functions and matching them with arguments.

Function Declarations in C

https://macronepal.com/c-function-declarations-syntax-rules-and-best-practices/
Covers prototypes, syntax rules, and best practices.

Function Calls in C

https://macronepal.com/understanding-function-calls-in-c-syntax-mechanics-and-best-practices/
Explains execution flow and parameter handling during function calls.

Void Functions in C

https://macronepal.com/understanding-void-functions-in-c-syntax-patterns-and-best-practices/
Explains functions that do not return values.

Return Values in C

https://macronepal.com/c-return-values-mechanics-types-and-best-practices/
Explains different return types and how functions return results.

Pass-by-Value in C

https://macronepal.com/aws/understanding-pass-by-value-in-c-mechanics-implications-and-best-practices/
Explains how copies of variables are passed into functions.

Pass-by-Reference in C

https://macronepal.com/c/understanding-pass-by-reference-in-c-pointers-semantics-and-safe-practices/
Explains using pointers to modify original variables.

C strstr() Function

https://macronepal.com/aws/c-strstr-function/
Explains substring search inside strings in C.

C Preprocessor & Macros

C Structures, Memory, Scope & Linkage

C Scope, Storage Classes & Typedef

Extra Articles

https://macronepal.com/13757-2/
https://macronepal.com/13748-2/
https://macronepal.com/13747-2/
https://macronepal.com/13746-2/
https://macronepal.com/13745-2/
https://macronepal.com/13708-2/
https://macronepal.com/13707-2/
https://macronepal.com/13702-2/

Online Compilers

Complete Guide to Core & Advanced C Programming Concepts (Functions, Strings, Arrays, Loops, I/O, Control Flow)

https://macronepal.com/bash/building-blocks-of-c-a-complete-guide-to-functions/
Explains how functions in C work as reusable blocks of code, including declaration, definition, parameters, return values, and modular programming structure.

https://macronepal.com/bash/the-heart-of-text-processing-a-complete-guide-to-strings-in-c-2/
Explains how strings are handled in C using character arrays, string manipulation techniques, and common library functions for text processing.

https://macronepal.com/bash/the-cornerstone-of-data-organization-a-complete-guide-to-arrays-in-c/
Explains arrays in C as structured memory storage for multiple values, including indexing, initialization, and efficient data organization.

https://macronepal.com/bash/guaranteed-execution-a-complete-guide-to-the-do-while-loop-in-c/
Explains the do-while loop in C, where the loop body executes at least once before checking the condition.

https://macronepal.com/bash/mastering-iteration-a-complete-guide-to-the-for-loop-in-c/
Explains the for loop in C, including initialization, condition checking, and increment/decrement for controlled iteration.

https://macronepal.com/bash/mastering-iteration-a-complete-guide-to-while-loops-in-c/
Explains the while loop in C, focusing on condition-based repetition and proper loop control mechanisms.

https://macronepal.com/bash/beyond-if-else-a-complete-guide-to-switch-case-in-c/
Explains switch-case statements in C, enabling multi-branch decision-making based on variable values.

https://macronepal.com/bash/mastering-conditional-logic-a-complete-guide-to-if-else-statements-in-c/
Explains if-else statements in C for decision-making and controlling program flow based on conditions.

https://macronepal.com/bash/mastering-the-fundamentals-a-complete-guide-to-arithmetic-operations-in-c/
Explains arithmetic operations in C such as addition, subtraction, multiplication, division, and operator precedence.

https://macronepal.com/bash/foundation-of-c-programming-a-complete-guide-to-basic-input-output/
Explains basic input and output in C using scanf and printf for interacting with users and displaying results.

Online C Code Compiler
https://macronepal.com/free-online-c-code-compiler-2/