MACRO NEPAL
C strcpy Function
awiskar acharya
April 29, 2026
12:33 pm

The strcpy() function copies a string from source to destination, including the null terminator \0. It is defined in the <string.h> header.

Basic Syntax

#include <string.h>
char *strcpy(char *destination, const char *source);
ParameterDescription
destinationPointer to destination array (must be large enough)
sourcePointer to source string to copy
Return valuePointer to destination (useful for chaining)

Example 1: Basic String Copy

#include <stdio.h>
#include <string.h>
int main() {
char source[] = "Hello World";
char destination[20];  // Must be large enough
strcpy(destination, source);
printf("Source: %s\n", source);
printf("Destination: %s\n", destination);
return 0;
}

Output:

Source: Hello World
Destination: Hello World

Example 2: Copying Partial Strings

#include <stdio.h>
#include <string.h>
int main() {
char text[] = "Programming in C";
char buffer[30];
// Copy entire string
strcpy(buffer, text);
printf("Full copy: %s\n", buffer);
// Copy from specific position using pointer arithmetic
strcpy(buffer, text + 4);  // Starts at position 4 ( 'r' )
printf("From index 4: %s\n", buffer);
// buffer now contains "ramming in C"
return 0;
}

Output:

Full copy: Programming in C
From index 4: ramming in C

Example 3: Chaining strcpy Calls

#include <stdio.h>
#include <string.h>
int main() {
char first[20];
char second[20];
char third[20];
// strcpy returns destination, allowing chaining
strcpy(third, strcpy(second, strcpy(first, "Chain")));
printf("First: %s\n", first);
printf("Second: %s\n", second);
printf("Third: %s\n", third);
return 0;
}

Output:

First: Chain
Second: Chain
Third: Chain

Example 4: Copying Between Arrays

#include <stdio.h>
#include <string.h>
int main() {
char name1[] = "Alice Johnson";
char name2[50];
char name3[50];
// Copy to another array
strcpy(name2, name1);
// Copy to itself is undefined behavior (don't do it)
// strcpy(name1, name1);  // ❌ BAD - Overlapping memory
// Modify original
strcpy(name1, "Bob Smith");
printf("Original: %s\n", name1);
printf("Copied (before): %s\n", name2);
// Copy again
strcpy(name3, name2);
printf("Second copy: %s\n", name3);
return 0;
}

Output:

Original: Bob Smith
Copied (before): Alice Johnson
Second copy: Alice Johnson

Example 5: Building Strings with strcpy and strcat

#include <stdio.h>
#include <string.h>
int main() {
char greeting[100];
char name[] = "John";
char exclamation[] = "!";
// Build: "Hello " + "John" + "!"
strcpy(greeting, "Hello ");
strcat(greeting, name);
strcat(greeting, exclamation);
printf("%s\n", greeting);
// Alternative using chaining
char message[100];
strcpy(strcpy(message, "Welcome, "), "Alice");
printf("%s\n", message);
return 0;
}

Output:

Hello John!
Welcome, Alice

Example 6: Copying String Literals

#include <stdio.h>
#include <string.h>
int main() {
char buffer[100];
// Copy string literal directly
strcpy(buffer, "Direct string literal");
printf("%s\n", buffer);
// Copy from const char* pointer
const char *msg = "Pointer to string";
strcpy(buffer, msg);
printf("%s\n", buffer);
// Copy multiple times (overwrites previous)
strcpy(buffer, "New content");
strcpy(buffer, "Overwritten again");
printf("%s\n", buffer);
return 0;
}

Output:

Direct string literal
Pointer to string
Overwritten again

The Danger: Buffer Overflow

#include <stdio.h>
#include <string.h>
int main() {
char small[5];  // Only 5 bytes capacity
// ❌ DANGEROUS - Source is larger than destination
// This will overflow and cause undefined behavior
char large[] = "This is too long";
// strcpy(small, large);  // CRASH or memory corruption!
// ✅ SAFE - Use strncpy or ensure size
char safe[50];
strcpy(safe, large);  // Safe because safe[] is large enough
printf("%s\n", safe);
return 0;
}

strcpy vs strncpy (Safe Alternative)

#include <stdio.h>
#include <string.h>
int main() {
char dest[10];
char src[] = "This is a very long string";
// strcpy - UNSAFE (will overflow)
// strcpy(dest, src);  // ❌ DON'T DO THIS
// strncpy - SAFER (copies max n characters)
strncpy(dest, src, sizeof(dest) - 1);  // Copy 9 chars
dest[sizeof(dest) - 1] = '\0';  // Manually add null terminator
printf("Copied: %s\n", dest);
// Note: strncpy doesn't add null terminator if src >= n
char dest2[5] = "XXXX";
strncpy(dest2, "Hi", 3);
printf("strncpy result: %s\n", dest2);  // "Hi" + null
return 0;
}

Output:

Copied: This is a
strncpy result: Hi

Comparison Table

FunctionCopies Null Terminator?Bounds Checked?Use Case
strcpy(dest, src)YesNoWhen dest size is guaranteed
strncpy(dest, src, n)Only if src shorter than nYesLimited copy (may need manual null)
strcpy_s(dest, size, src) (C11)YesYesSafe version (optional in C11)

Common Mistakes

// ❌ WRONG - Destination too small
char dest[5];
char src[] = "Hello World";
strcpy(dest, src);  // Overflow!
// ✅ CORRECT - Ensure destination is large enough
char dest[50];
strcpy(dest, src);
// ❌ WRONG - Uninitialized destination
char *dest;  // Points to random memory
strcpy(dest, "text");  // CRASH
// ✅ CORRECT - Use array or malloc
char dest[20];
char *ptr = malloc(20);
strcpy(ptr, "text");
// ❌ WRONG - Overlapping memory
char str[20] = "Hello";
strcpy(str + 1, str);  // Undefined behavior
// ✅ CORRECT - Use memmove for overlapping
memmove(str + 1, str, 6);  // Safe overlapping copy

Practical Example: String Array Copy

#include <stdio.h>
#include <string.h>
int main() {
char original[5][20] = {
"Apple",
"Banana",
"Cherry",
"Date",
"Elderberry"
};
char copy[5][20];
// Copy entire array of strings
for(int i = 0; i < 5; i++) {
strcpy(copy[i], original[i]);
}
// Modify original
strcpy(original[0], "Apricot");
strcpy(original[1], "Blueberry");
printf("Original:\n");
for(int i = 0; i < 5; i++) {
printf("  %s\n", original[i]);
}
printf("\nCopy (unchanged):\n");
for(int i = 0; i < 5; i++) {
printf("  %s\n", copy[i]);
}
return 0;
}

Output:

Original:
Apricot
Blueberry
Cherry
Date
Elderberry
Copy (unchanged):
Apple
Banana
Cherry
Date
Elderberry

Return Value Usage

#include <stdio.h>
#include <string.h>
int main() {
char buffer[100];
int length;
// strcpy returns pointer to destination
char *result = strcpy(buffer, "Hello");
// Check if success (always returns dest unless error)
if(result == buffer) {
printf("Copy successful\n");
}
// Can use return value in expressions
length = strlen(strcpy(buffer, "New string"));
printf("Length of '%s' is %d\n", buffer, length);
return 0;
}

Output:

Copy successful
Length of 'New string' is 10

Quick Summary

OperationCodeNotes
Basic copystrcpy(dest, src)dest must be large enough
Safe copystrncpy(dest, src, size-1); dest[size-1]=0Always null terminate
Copy literalstrcpy(dest, "text")Works directly
Chain copiesstrcpy(dest2, strcpy(dest1, src))Returns destination
Copy pointer contentstrcpy(dest, ptr)ptr must point to valid string

Best Practice Rules

  1. Always ensure destination is large enough for source + null terminator
  2. Use strncpy() for safety when size isn't guaranteed
  3. Manually add null terminator after strncpy() if needed
  4. Never use strcpy() with user input without validation
  5. Never copy between overlapping strings (use memmove())
  6. C11's strcpy_s() is safe but not universally available

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