The strncat() function appends a specified number of characters from a source string to the end of a destination string. It is safer than strcat() because it prevents buffer overflow by limiting how many characters are copied.

Table of Contents

Basic Syntax

#include <string.h>
char *strncat(char *destination, const char *source, size_t n);

Parameter	Description
`destination`	Target string (must have enough space)
`source`	String to append from
`n`	Maximum number of characters to append
Return value	Pointer to destination (useful for chaining)

Key behavior: Always adds a null terminator \0 at the end.

Example 1: Basic strncat Usage

#include <stdio.h>
#include <string.h>
int main() {
char dest[20] = "Hello ";
char src[] = "World";
strncat(dest, src, 3);  // Append only 3 characters
printf("Result: %s\n", dest);
return 0;
}

Output:

Result: Hello Wor

Example 2: strncat vs strcat (Safety)

#include <stdio.h>
#include <string.h>
int main() {
char buffer1[10] = "Hi ";
char buffer2[10] = "Hi ";
char src[] = "This is a very long string";
// strcat - UNSAFE (will overflow)
// strcat(buffer1, src);  // ❌ CRASH or corruption
// strncat - SAFE (limits to available space)
strncat(buffer2, src, sizeof(buffer2) - strlen(buffer2) - 1);
printf("Safe append: %s\n", buffer2);
return 0;
}

Output:

Safe append: Hi This i

Example 3: Appending Different Lengths

#include <stdio.h>
#include <string.h>
int main() {
char dest[50] = "Hello";
char src[] = " World!";
strncat(dest, src, 2);
printf("Append 2 chars: %s\n", dest);
// Reset
strcpy(dest, "Hello");
strncat(dest, src, 5);
printf("Append 5 chars: %s\n", dest);
// Reset
strcpy(dest, "Hello");
strncat(dest, src, 10);  // n larger than source length
printf("Append more than source: %s\n", dest);
return 0;
}

Output:

Append 2 chars: Hello W
Append 5 chars: Hello Worl
Append more than source: Hello World!

Example 4: Building Strings Safely

#include <stdio.h>
#include <string.h>
int main() {
char message[30] = "User: ";
char username[] = "alexander_the_great";
char status[] = " [online]";
// Safely append with space limit
int remaining = sizeof(message) - strlen(message) - 1;
strncat(message, username, remaining);
// Reset and use different approach
char safeMsg[20] = "Status: ";
strncat(safeMsg, status, sizeof(safeMsg) - strlen(safeMsg) - 1);
printf("%s\n", message);
printf("%s\n", safeMsg);
return 0;
}

Output:

User: alexander_the_great
Status:  [online]

Example 5: Append from Middle of Source String

#include <stdio.h>
#include <string.h>
int main() {
char dest[50] = "Extracted: ";
char data[] = "FirstName:John,LastName:Doe";
// Append from specific position in source
strncat(dest, data + 10, 4);   // Skip "FirstName:" (10 chars)
printf("%s\n", dest);
// Another example
char path[100] = "/home/";
char full[] = "user/documents/file.txt";
strncat(path, full, 4);  // Append "user"
printf("Path: %s\n", path);
return 0;
}

Output:

Extracted: John
Path: /home/user

Example 6: strncat with Return Value Chaining

#include <stdio.h>
#include <string.h>
int main() {
char result[100] = "";
// strncat returns destination, allowing chaining
strncat(strncat(result, "Hello ", 6), "World", 5);
printf("Chained: %s\n", result);
// Another chain
char buffer[50] = "Start";
strncat(strncat(buffer, " + Middle", 9), " + End", 5);
printf("More chaining: %s\n", buffer);
return 0;
}

Output:

Chained: Hello World
More chaining: Start + Middle + End

Safer strncat Wrapper Function

#include <stdio.h>
#include <string.h>
// Safe wrapper that prevents buffer overflow
void safe_strncat(char *dest, const char *src, size_t dest_size) {
size_t dest_len = strlen(dest);
size_t remaining = dest_size - dest_len - 1;
if(remaining > 0) {
strncat(dest, src, remaining);
}
}
int main() {
char buffer[20] = "Hello ";
char input[] = "This is a very long input string";
printf("Before: '%s' (length: %zu)\n", buffer, strlen(buffer));
safe_strncat(buffer, input, sizeof(buffer));
printf("After:  '%s' (length: %zu)\n", buffer, strlen(buffer));
return 0;
}

Output:

Before: 'Hello ' (length: 6)
After:  'Hello This is a ' (length: 18)

strncat vs Other Functions

Function	Adds Null Terminator?	Bounds Checked?	Appends At Most n chars	Use Case
`strcat(dest, src)`	Yes	No	No (copies all)	Safe when size guaranteed
`strncat(dest, src, n)`	Yes	Partial	Yes	Safer, limited append
`strncpy(dest, src, n)`	Only if src shorter	Partial	Yes (overwrites, not appends)	Copying, not appending
`memcpy(dest, src, n)`	No	Partial	Yes	Low-level byte copy

Important Behavior Details

#include <stdio.h>
#include <string.h>
int main() {
char dest[20] = "ABC";
char src[] = "XYZ123";
// strncat ALWAYS adds null terminator
strncat(dest, src, 2);
printf("After appending 2 chars: %s\n", dest);
// Result: "ABCXY" (null terminated)
// Even if n = 0, still works (adds nothing, but dest unchanged)
char dest2[20] = "Hello";
strncat(dest2, src, 0);
printf("n = 0: %s\n", dest2);  // Still "Hello"
// strncat doesn't care about nulls in source middle
char src_with_null[] = "AB\0CD";
char dest3[20] = "Start";
strncat(dest3, src_with_null, 4);
printf("Stops at null: %s\n", dest3);  // "StartAB"
return 0;
}

Output:

After appending 2 chars: ABCXY
n = 0: Hello
Stops at null: StartAB

Common Mistakes

#include <stdio.h>
#include <string.h>
int main() {
// ❌ WRONG - Destination too small
char small[9] = "12345678";
char append[] = "Extra";
// strncat(small, append, 5);  // Overflow!
// ✅ CORRECT - Calculate remaining space first
char buffer[15] = "12345678";
size_t used = strlen(buffer);
size_t available = sizeof(buffer) - used - 1;
strncat(buffer, append, available);
printf("Safe append: %s\n", buffer);
// ❌ WRONG - Forgetting space for null terminator
char dest[10] = "Hello";
// strncat(dest, "World", 5);  // Needs 5+5+1=11 bytes, but dest is 10
// Should use available = sizeof(dest) - strlen(dest) - 1 = 4
// ✅ CORRECT - Proper buffer size calculation
char correct[11] = "Hello";
strncat(correct, "World", 5);
printf("Correct size: %s\n", correct);
return 0;
}

Practical Example: Formatting User Input

#include <stdio.h>
#include <string.h>
#define MAX_LENGTH 50
int main() {
char log_entry[MAX_LENGTH] = "[INFO] ";
char user_input[100];
printf("Enter log message (max %d chars): ", MAX_LENGTH - 20);
fgets(user_input, sizeof(user_input), stdin);
// Remove newline from input
user_input[strcspn(user_input, "\n")] = '\0';
// Safely append to log entry
size_t remaining = sizeof(log_entry) - strlen(log_entry) - 1;
strncat(log_entry, user_input, remaining);
// Add timestamp manually
char timestamp[] = " [2024]";
remaining = sizeof(log_entry) - strlen(log_entry) - 1;
strncat(log_entry, timestamp, remaining);
printf("Final log: %s\n", log_entry);
return 0;
}

Input/Output:

Enter log message (max 30 chars): User logged in successfully
Final log: [INFO] User logged in successfully [2024]

Performance Tips

#include <stdio.h>
#include <string.h>
int main() {
char buffer[1000] = "Start";
char data[] = "data";
// SLOW - Finding strlen each time (O(n²) behavior)
for(int i = 0; i < 100; i++) {
strncat(buffer, data, 4);
}
// FAST - Track length manually (O(n) behavior)
char fast[1000] = "Start";
size_t len = strlen(fast);
for(int i = 0; i < 100; i++) {
len += strncat(fast + len, data, 4) - fast;
// Or simply: strcpy(fast + len, data); len += 4;
}
printf("Both string length: %zu\n", strlen(fast));
return 0;
}

Quick Reference Card

Operation	Code	Notes
Basic append	`strncat(dest, src, 3)`	Appends 3 chars
Safe append	`strncat(dest, src, sizeof(dest)-strlen(dest)-1)`	Prevents overflow
Append from offset	`strncat(dest, src+5, 2)`	Skips first 5 chars
Chain appends	`strncat(strncat(dest, a, n), b, m)`	Multiple in one line
Append nothing	`strncat(dest, src, 0)`	No change to dest
Append entire	`strncat(dest, src, strlen(src))`	Same as strcat
Append partial string literal	`strncat(dest, "Hello", 3)`	"Hel" appended

Best Practices

Always calculate remaining space before using strncat
Use the pattern: strncat(dest, src, sizeof(dest) - strlen(dest) - 1)
Remember: strncat always adds null terminator
Prefer strncat over strcat when dealing with user input
Track string length manually for multiple appends to avoid O(n²) performance
Check if n should be sizeof(dest) - strlen(dest) - 1 for maximum safety

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/

Basic Syntax

Example 1: Basic strncat Usage

Example 2: strncat vs strcat (Safety)

Example 3: Appending Different Lengths

Example 4: Building Strings Safely

Example 5: Append from Middle of Source String

Example 6: strncat with Return Value Chaining

Safer strncat Wrapper Function

strncat vs Other Functions

Important Behavior Details

Common Mistakes

Practical Example: Formatting User Input

Performance Tips

Quick Reference Card

Best Practices

Complete C Programming Guide + Compilers Collection

1. C srand() Function – Understanding Seed Initialization

2. C rand() Function Mechanics and Limitations

3. C log() Function

4. Mastering Date and Time in C

5. Mastering time_t Type in C

6. C exp() Function

7. C log() Function (Alternate Guide)

8. C log10() Function

9. C tan() Function

10. Random Numbers in C (Secure vs Predictable)

11. Free Online C Compiler

C Functions, Arguments, Parameters & Flow

Mastering Functions in C – Complete Guide

Function Arguments in C

Function Parameters in C

Function Declarations in C

Function Calls in C

Void Functions in C

Return Values in C

Pass-by-Value in C

Pass-by-Reference in C

C strstr() Function

C Preprocessor & Macros

C Structures, Memory, Scope & Linkage

C Scope, Storage Classes & Typedef

Extra Articles

Online Compilers

Leave a Reply Cancel reply

Macro Nepal Helper