MACRO NEPAL
C strcat Function
awiskar acharya
April 29, 2026
12:37 pm

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);
ParameterDescription
destinationThe target string where source will be appended
sourceThe string to be appended
Return valuePointer 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);
ParameterDescription
destDestination string
srcSource string
nMaximum number of characters to append
ReturnPointer 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

Featurestrcat()strncat()
SafetyUnsafe (no bounds check)Safer (bounds check)
Parameters2 parameters3 parameters (adds max length)
Buffer overflowPossiblePrevented
PerformanceSlightly fasterSlightly slower (extra check)
Use caseKnown safe sizesUnknown 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 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/

Category : C

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper