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/