Table of Contents

What is a String in C?

A string in C is a sequence of characters ending with a null character '\0'. Unlike other programming languages, C doesn't have a built-in string type. Strings are stored as character arrays terminated by null.

String Declaration Syntax

char string_name[size];
char string_name[] = "text";
char *string_name = "text";

Ways to Declare Strings

1. Character Array with Size

#include <stdio.h>
int main() {
char name[20];  // Can hold up to 19 chars + null terminator
// Assigning values
name[0] = 'J';
name[1] = 'o';
name[2] = 'h';
name[3] = 'n';
name[4] = '\0';  // MUST add null character
printf("%s\n", name);  // John
return 0;
}

2. Initialize at Declaration (Array)

#include <stdio.h>
int main() {
char str1[6] = "Hello";   // Size 6 = 5 letters + '\0'
char str2[] = "World";    // Size auto-detected (6 chars)
printf("%s %s\n", str1, str2);  // Hello World
printf("Size of str2: %lu\n", sizeof(str2));  // 6 bytes
return 0;
}

3. Character-by-Character Initialization

#include <stdio.h>
int main() {
// MUST include null character manually
char str1[5] = {'C', 'o', 'd', 'e', '\0'};
char str2[] = {'C', 'o', 'd', 'e', '\0'};  // Auto-size
printf("%s\n", str1);  // Code
printf("%s\n", str2);  // Code
// WRONG - no null terminator (will print garbage)
char str3[4] = {'T', 'e', 's', 't'};  // Missing '\0'
printf("%s\n", str3);  // Undefined behavior
return 0;
}

4. String Pointer Declaration

#include <stdio.h>
int main() {
char *str1 = "Hello";
const char *str2 = "World";  // Recommended for string literals
printf("%s %s\n", str1, str2);  // Hello World
// str1[0] = 'h';  // ERROR! String literals are read-only
// For modifiable strings, use array
char str3[] = "Hello";
str3[0] = 'h';  // OK
printf("%s\n", str3);  // hello
return 0;
}

String Input Methods

Using `scanf()` - Reads until whitespace

#include <stdio.h>
int main() {
char name[50];
printf("Enter your name: ");
scanf("%s", name);  // No & needed (array name is pointer)
printf("Hello, %s!\n", name);
return 0;
}
// Input: John Doe
// Output: Hello, John!  (stops at space)

Using `fgets()` - Reads entire line (safer)

#include <stdio.h>
int main() {
char fullname[100];
printf("Enter full name: ");
fgets(fullname, sizeof(fullname), stdin);  // Safe, reads spaces
printf("You entered: %s", fullname);
return 0;
}
// Input: John Michael Doe
// Output: You entered: John Michael Doe

Using `gets()` - DANGEROUS (NEVER USE)

// WARNING: gets() is removed from C11
// char str[100];
// gets(str);  // No bounds checking - buffer overflow risk!

String Output Methods

Using `printf()` with `%s`

#include <stdio.h>
int main() {
char str[] = "Cloud Computing";
printf("String: %s\n", str);
return 0;
}

Using `puts()` - Adds newline automatically

#include <stdio.h>
int main() {
char str1[] = "Hello";
char str2[] = "World";
puts(str1);  // Prints "Hello\n"
puts(str2);  // Prints "World\n"
return 0;
}
/* Output:
Hello
World
*/

Common String Operations (Using `<string.h>`)

1. String Length - `strlen()`

#include <stdio.h>
#include <string.h>
int main() {
char str[] = "Computer";
int len = strlen(str);  // Returns actual length (8)
int size = sizeof(str); // Returns array size including '\0' (9)
printf("Length: %d\n", len);   // 8
printf("Size: %d\n", size);    // 9
return 0;
}

2. String Copy - `strcpy()`

#include <stdio.h>
#include <string.h>
int main() {
char source[] = "Cloud Computing";
char destination[50];
strcpy(destination, source);  // Copy source to destination
printf("Copied string: %s\n", destination);
// Safe copy (limits characters)
char safe_dest[10];
strncpy(safe_dest, source, 9);
safe_dest[9] = '\0';
printf("Safe copy: %s\n", safe_dest);
return 0;
}

3. String Concatenation - `strcat()`

#include <stdio.h>
#include <string.h>
int main() {
char str1[50] = "Hello ";
char str2[] = "World";
strcat(str1, str2);  // Appends str2 to str1
printf("%s\n", str1);  // Hello World
// Safe concatenation
char str3[20] = "Good";
strncat(str3, " Morning", 8);
printf("%s\n", str3);  // Good Morning
return 0;
}

4. String Comparison - `strcmp()`

#include <stdio.h>
#include <string.h>
int main() {
char str1[] = "Apple";
char str2[] = "Apple";
char str3[] = "Banana";
int result1 = strcmp(str1, str2);  // 0 (equal)
int result2 = strcmp(str1, str3);  // Negative (Apple < Banana)
int result3 = strcmp(str3, str1);  // Positive (Banana > Apple)
printf("str1 vs str2: %d\n", result1);  // 0
printf("str1 vs str3: %d\n", result2);  // -1 or negative
printf("str3 vs str1: %d\n", result3);  // 1 or positive
return 0;
}

5. String Search - `strchr()` and `strstr()`

#include <stdio.h>
#include <string.h>
int main() {
char str[] = "Cloud Computing is powerful";
// Find first occurrence of character
char *ch = strchr(str, 'C');
printf("First 'C' at position: %ld\n", ch - str);  // 0
// Find substring
char *sub = strstr(str, "Computing");
if(sub != NULL) {
printf("Found: %s\n", sub);  // Computing is powerful
}
return 0;
}

String Arrays (Array of Strings)

Declaration Methods

#include <stdio.h>
int main() {
// Method 1: 2D character array
char fruits[3][20] = {
"Apple",
"Banana",
"Orange"
};
// Method 2: Array of pointers
const char *colors[] = {"Red", "Green", "Blue"};
// Accessing
printf("First fruit: %s\n", fruits[0]);   // Apple
printf("Second color: %s\n", colors[1]);  // Green
// Modifying 2D array (allowed)
fruits[0][0] = 'a';
printf("Modified: %s\n", fruits[0]);  // apple
// Modifying pointer array (NOT allowed - string literals)
// colors[0][0] = 'r';  // ERROR!
return 0;
}

Iterating Through String Array

#include <stdio.h>
int main() {
char names[4][20] = {"Alice", "Bob", "Charlie", "Diana"};
printf("Names:\n");
for(int i = 0; i < 4; i++) {
printf("%d. %s\n", i+1, names[i]);
}
return 0;
}

String Input with Spaces

#include <stdio.h>
#include <string.h>
int main() {
char sentence[200];
printf("Enter a sentence: ");
fgets(sentence, sizeof(sentence), stdin);
// Remove trailing newline (if present)
sentence[strcspn(sentence, "\n")] = '\0';
printf("You typed: %s\n", sentence);
return 0;
}

Common String Functions Reference

Function	Purpose	Example
`strlen(str)`	Length of string	`int len = strlen("Hi");` // 2
`strcpy(dest, src)`	Copy string	`strcpy(dest, src);`
`strcat(dest, src)`	Concatenate	`strcat(dest, src);`
`strcmp(str1, str2)`	Compare strings	`if(strcmp(a,b)==0)`
`strchr(str, ch)`	Find character	`strchr("Hi", 'i');`
`strstr(str, sub)`	Find substring	`strstr("Hello", "ell");`
`strlwr(str)`	Convert to lowercase	Non-standard
`strupr(str)`	Convert to uppercase	Non-standard

Important Rules and Tips

#include <stdio.h>
#include <string.h>
int main() {
// Rule 1: Always leave space for '\0'
char correct[5] = "Hi";   // 'H','i','\0' (2 used, 3 wasted)
char wrong[2] = "Hi";     // ERROR! No space for '\0'
// Rule 2: sizeof vs strlen
char text[] = "Hello";
printf("sizeof: %lu\n", sizeof(text));  // 6 (includes '\0')
printf("strlen: %lu\n", strlen(text));  // 5 (no '\0')
// Rule 3: Array vs Pointer
char arr[] = "Fixed";     // Modifiable, fixed address
char *ptr = "Literal";    // Read-only, can point elsewhere
arr[0] = 'f';   // OK
// ptr[0] = 'l'; // WRONG - undefined behavior
ptr = "New";    // OK - pointer can point elsewhere
return 0;
}

Quick Comparison Table

Declaration	Modifiable	Memory Location	Can Reassign
`char str[10] = "Hi";`	Yes	Stack	No (array)
`char str[] = "Hi";`	Yes	Stack	No (array)
`char *str = "Hi";`	No	Read-only	Yes (pointer)
`char *str = malloc(10);`	Yes	Heap	Yes (pointer)

Key Points to Remember

All C strings end with null character '\0'
Array size must be at least (string length + 1)
sizeof() returns array size (includes \0)
strlen() returns string length (excludes \0)
Never use gets() - use fgets() instead
String literals are read-only when using pointers
Always include <string.h> for string functions
Use strncpy() and strncat() for safe operations

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/