MACRO NEPAL
C strncat Function
awiskar acharya
April 29, 2026
12:36 pm

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.

Basic Syntax

#include <string.h>
char *strncat(char *destination, const char *source, size_t n);
ParameterDescription
destinationTarget string (must have enough space)
sourceString to append from
nMaximum number of characters to append
Return valuePointer 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

FunctionAdds Null Terminator?Bounds Checked?Appends At Most n charsUse Case
strcat(dest, src)YesNoNo (copies all)Safe when size guaranteed
strncat(dest, src, n)YesPartialYesSafer, limited append
strncpy(dest, src, n)Only if src shorterPartialYes (overwrites, not appends)Copying, not appending
memcpy(dest, src, n)NoPartialYesLow-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

OperationCodeNotes
Basic appendstrncat(dest, src, 3)Appends 3 chars
Safe appendstrncat(dest, src, sizeof(dest)-strlen(dest)-1)Prevents overflow
Append from offsetstrncat(dest, src+5, 2)Skips first 5 chars
Chain appendsstrncat(strncat(dest, a, n), b, m)Multiple in one line
Append nothingstrncat(dest, src, 0)No change to dest
Append entirestrncat(dest, src, strlen(src))Same as strcat
Append partial string literalstrncat(dest, "Hello", 3)"Hel" appended

Best Practices

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

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