String Operations

A name. An email. A message someone typed. All of these are strings. A string is just text. It is a row of characters sitting one after another. But raw text on its own does not do much. You have to measure it. Cut it. Join it. Check it. That is what string operations are. They are the small jobs you do on text again and again in real programs.

Let me walk you through the common ones. We will do each one in a tiny program. That way you see the input and the exact output side by side.

🎯 The Pain First

Say you are building the sign-up screen for an app. A user types their full name as “Riya Sharma”. Now your code has to do real work on that text.

• You want to check the name is not too short. So you need its length.
• You want to grab just the first letter for a profile badge. So you need one character by its index.
• You want to greet them with “Hello, Riya Sharma!”. So you need to join pieces of text together.

Every one of these is a string operation. Learn the handful below. After that, most everyday text work feels easy.

📏 Length: How Long Is the Text?

The length of a string is the count of characters in it. So “Riya” has a length of 4.

You ask for length when you want to check input or loop over each character. Is a password too short? Is a tweet too long? Both checks start with length.

🔤 Access a Character by Index

A string is ordered. Each character sits at a position called an index. And indexing starts at 0. So in “Riya” the character at index 0 is ‘R’. The character at index 1 is ‘i’.

You use this when you want one specific letter. The first letter for a badge. The last letter to check something. Just remember the start is index 0, not 1.

🔗 Concatenate: Join Two Strings

Concatenation means sticking strings together to make one longer string. So joining “Hello, ” and “Riya” gives you “Hello, Riya”.

This is how you build messages out of parts. A greeting. A file path. A full name made from a first name and a last name.

✂️ Substring: Take a Slice

A substring is a smaller piece taken out of a string. You pick a start position and an end position. You get back the characters in between. So from “Riya Sharma”, a slice from index 0 up to 4 gives you “Riya”.

You reach for this when you want only part of the text. The area code from a phone number. The file name from a path. The first word from a sentence.

⚖️ Compare Two Strings

Comparing strings checks if two pieces of text are the same. Or which one comes first in dictionary order. So “apple” and “apple” are equal. And “apple” comes before “banana”.

You compare strings all the time. Checking a typed password against the saved one. Sorting names into A to Z order. Matching a search word.

🔡 Convert Case

Changing case means turning every letter to uppercase or to lowercase. So “Riya” in lowercase is “riya”. In uppercase it is “RIYA”.

This is mostly used to compare text fairly. A user might type “GMAIL” or “gmail”. If you lowercase both first, they match. So case conversion makes your checks forgiving.

🛠️ One Program, Many Operations

Now let me put all of these into one small program. We start with the string “Riya Sharma”. Then we run each operation on it and print the result. Read the comments and the output together.

#include <stdio.h>
#include <string.h>
#include <ctype.h>

// Run common string operations and print each result
void stringOps(const char *text) {
    // 1) Length: strlen counts characters up to the end marker
    printf("Length: %zu\n", strlen(text));

    // 2) Character at index 0 (the first character)
    printf("Char at index 0: %c\n", text[0]);

    // 3) Concatenate: build "Hello, " + text into one buffer
    char joined[50];
    strcpy(joined, "Hello, ");
    strcat(joined, text);
    printf("Concatenated: %s\n", joined);

    // 4) Substring: copy characters from index 0, length 4
    char sub[5];
    strncpy(sub, text, 4);
    sub[4] = '\0'; // add the end marker by hand
    printf("Substring (0..4): %s\n", sub);

    // 5) Compare with another string (0 means equal)
    printf("Compare with 'Riya Sharma': %d\n", strcmp(text, "Riya Sharma"));

    // 6) Convert to uppercase, one character at a time
    char upper[50];
    strcpy(upper, text);
    for (int i = 0; upper[i] != '\0'; i++) {
        upper[i] = toupper((unsigned char)upper[i]);
    }
    printf("Uppercase: %s\n", upper);
}

int main() {
    const char *text = "Riya Sharma";
    stringOps(text);
    return 0;
}

Length: 11
Char at index 0: R
Concatenated: Hello, Riya Sharma
Substring (0..4): Riya
Compare with 'Riya Sharma': 0
Uppercase: RIYA SHARMA

#include <iostream>
#include <string>
#include <algorithm>
#include <cctype>
using namespace std;

// Run common string operations and print each result
void stringOps(const string &text) {
    // 1) Length: size() returns the character count
    cout << "Length: " << text.size() << endl;

    // 2) Character at index 0 (the first character)
    cout << "Char at index 0: " << text[0] << endl;

    // 3) Concatenate: + joins two strings into one
    cout << "Concatenated: " << ("Hello, " + text) << endl;

    // 4) Substring: substr(start, count) takes a slice
    cout << "Substring (0..4): " << text.substr(0, 4) << endl;

    // 5) Compare (0 means the text is equal)
    cout << "Compare with 'Riya Sharma': " << text.compare("Riya Sharma") << endl;

    // 6) Convert to uppercase
    string upper = text;
    transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
    cout << "Uppercase: " << upper << endl;
}

int main() {
    string text = "Riya Sharma";
    stringOps(text);
    return 0;
}

Length: 11
Char at index 0: R
Concatenated: Hello, Riya Sharma
Substring (0..4): Riya
Compare with 'Riya Sharma': 0
Uppercase: RIYA SHARMA

public class StringOps {

    // Run common string operations and print each result
    static void stringOps(String text) {
        // 1) Length: length() returns the character count
        System.out.println("Length: " + text.length());

        // 2) Character at index 0 (the first character)
        System.out.println("Char at index 0: " + text.charAt(0));

        // 3) Concatenate: + joins two strings into one
        System.out.println("Concatenated: " + ("Hello, " + text));

        // 4) Substring: substring(start, end) takes a slice
        System.out.println("Substring (0..4): " + text.substring(0, 4));

        // 5) Compare (true means the text is equal)
        System.out.println("Equals 'Riya Sharma': " + text.equals("Riya Sharma"));

        // 6) Convert to uppercase
        System.out.println("Uppercase: " + text.toUpperCase());
    }

    public static void main(String[] args) {
        String text = "Riya Sharma";
        stringOps(text);
    }
}

Length: 11
Char at index 0: R
Concatenated: Hello, Riya Sharma
Substring (0..4): Riya
Equals 'Riya Sharma': true
Uppercase: RIYA SHARMA

# Run common string operations and print each result
def string_ops(text):
    # 1) Length: len() returns the character count
    print("Length:", len(text))

    # 2) Character at index 0 (the first character)
    print("Char at index 0:", text[0])

    # 3) Concatenate: + joins two strings into one
    print("Concatenated:", "Hello, " + text)

    # 4) Substring: slicing text[start:end] takes a slice
    print("Substring (0..4):", text[0:4])

    # 5) Compare (True means the text is equal)
    print("Equals 'Riya Sharma':", text == "Riya Sharma")

    # 6) Convert to uppercase
    print("Uppercase:", text.upper())

def main():
    text = "Riya Sharma"
    string_ops(text)

if __name__ == "__main__":
    main()

Length: 11
Char at index 0: R
Concatenated: Hello, Riya Sharma
Substring (0..4): Riya
Equals 'Riya Sharma': True
Uppercase: RIYA SHARMA

// Run common string operations and print each result
function stringOps(text) {
    // 1) Length: .length gives the character count
    console.log("Length:", text.length);

    // 2) Character at index 0 (the first character)
    console.log("Char at index 0:", text[0]);

    // 3) Concatenate: + joins two strings into one
    console.log("Concatenated:", "Hello, " + text);

    // 4) Substring: slice(start, end) takes a slice
    console.log("Substring (0..4):", text.slice(0, 4));

    // 5) Compare (true means the text is equal)
    console.log("Equals 'Riya Sharma':", text === "Riya Sharma");

    // 6) Convert to uppercase
    console.log("Uppercase:", text.toUpperCase());
}

function main() {
    const text = "Riya Sharma";
    stringOps(text);
}
main();

Length: 11
Char at index 0: R
Concatenated: Hello, Riya Sharma
Substring (0..4): Riya
Equals 'Riya Sharma': true
Uppercase: RIYA SHARMA

⏱️ A Quick Word on Cost

Most of these operations are cheap. But not all of them. And it helps to know which is which.

• In Python, JavaScript, Java, and C++, the length is stored with the string. So asking for length is O(1). It is instant, no matter how long the text is.
• In C there is no stored length. strlen walks the whole string and counts characters until it hits the end marker. So in C length is O(n), where n is the number of characters.
• Reading one character by index is O(1) everywhere. You jump straight to that position.
• Concatenation, substring, and case conversion all build a new string for the result. So each one is O(n). It touches every character it copies.

That concatenation cost is the one that catches people out. Joining text once is fine. But joining inside a long loop copies more and more each time. So the total work grows fast.

📊 Complexity of Common String Operations

Here n is the number of characters in the string.

⚠️ Common Mistakes

A few small slips trip up almost every beginner. Let me point them out.

• Thinking index starts at 1. The first character is at index 0, not 1. So the last character of a string of length n sits at index n minus 1.
• Forgetting spaces count. A space is a character. So “Riya Sharma” is length 11. And trailing spaces sneak into your length and your compares.
• Using == to compare text in Java or C. Use .equals in Java and strcmp in C. The == there checks the wrong thing.
• Joining strings inside a big loop. Each + makes a fresh copy. Over many rounds that gets slow. Collect the pieces and join them once.
• Mixing up case when comparing. “Gmail” and “gmail” are not equal as plain text. Lowercase both first if you want a fair match.

🧩 What You’ve Learned

You now know the everyday string operations. And you know what each one costs. Here is the recap.

• ✅ Length gives the character count, and spaces count too.
• ✅ Characters sit at indexes starting from 0, and reading one is instant.
• ✅ Concatenation joins strings, and substring takes a slice out of one.
• ✅ Compare checks if text is equal or which comes first, and the right tool differs by language.
• ✅ Case conversion turns text all upper or all lower, mostly to make compares fair.
• ✅ Length is O(1) in most languages but O(n) in C, while concatenate, substring, and case conversion all cost O(n).

🚀 What’s Next?

You can measure, cut, join, and compare text now. Build on that next.

• Introduction to Strings goes deeper into what a string really is and how it sits in memory.
• String Searching shows how to find one piece of text inside another, which is where these basics start paying off.

Practice each operation once on your own name. After that, the rest of string work will feel natural.