C++ for C Developers | Lesson 1: Hello, C++! (Similarities, Basic I/O, Namespaces)

Goal: Understand that C++ builds upon C, learn the basic structure of a C++ program, see the fundamental I/O mechanism (cout), and understand why namespaces (std) are used.

1. C is (Mostly) a Subset of C++

Good news! Much of your C knowledge is directly applicable. C++ was designed to be largely compatible with C. You can often compile C code with a C++ compiler.

• Familiar Syntax: Control structures (if, else, while, for, switch), basic data types (int, float, char, double), pointers, arrays, structs, and operators work largely the same way.
• Standard C Library: You can still use functions from <stdio.h>, <stdlib.h>, <string.h>, etc., although C++ provides its own, often safer and more powerful, alternatives (which we’ll cover). In C++, you typically include the C headers using a c prefix and omitting the .h (e.g., #include <cstdio>, #include <cstdlib>).

2. Your First C++ Program: “Hello, World!”

Let’s look at the classic example and compare it to C.

C Version:

#include <stdio.h> // Standard Input/Output library

int main() {
    printf("Hello, C World!\n");
    return 0;
}

C++ Version:

#include <iostream> // Input/Output Stream library

int main() {
    // Print "Hello, C++ World!" to the console
    std::cout << "Hello, C++ World!" << std::endl;
    return 0; // Indicates successful execution
}

Key Differences Observed:

• Header: We use #include <iostream> instead of <stdio.h>. This header defines C++’s stream-based I/O facilities.
• Output Statement: Instead of printf(), we use std::cout << ... ;.
  • std::cout: Represents the standard output stream (usually the console).
  • <<: This is the “stream insertion operator”. It “inserts” the data on its right into the stream on its left. You can chain it (std::cout << "Hello" << " " << "World!";).
  • std::endl: This inserts a newline character (\n) and flushes the output buffer (ensuring the text appears immediately). It’s often preferred over just "\n" in simple console output.
• std:: Prefix: Notice the std:: before cout and endl. What’s that?

3. Namespaces: Avoiding Name Collisions

Imagine you’re using two different libraries, and both define a function called doSomething(). How does the compiler know which one you mean? C struggles with this (often resorting to long, unique prefixes).

C++ uses namespaces to group related identifiers (like functions, classes, variables). The entire C++ Standard Library is defined within the std namespace.

• std::cout: This tells the compiler: “Use the cout object defined inside the std namespace.”
• std::endl: This tells the compiler: “Use the endl manipulator defined inside the std namespace.”

Using using (Use with Caution):

You might see code like this:

#include <iostream>
using namespace std; // Bring everything from 'std' into the current scope

int main() {
    cout << "Hello without std:: prefix!" << endl; // No 'std::' needed now
    return 0;
}

The using namespace std; directive imports all names from the std namespace into the global scope.

• Pro: Saves typing std::.
• Con: Defeats the purpose of namespaces! It increases the risk of name collisions, especially in larger projects or when included in header files. Best Practice: Avoid using namespace std; in header files. In .cpp files, it’s generally better to explicitly qualify names with std:: or use using declarations for specific names (e.g., using std::cout;, using std::endl;). For simplicity in these lessons, we might use it occasionally in small examples, but be aware of the implications.

4. Compiling C++ Code

You’ll use a C++ compiler (like g++ or Clang++). The command is similar to C:

graph TD
    A[Write C++ Source Code<br><code>my_program.cpp</code>] --> B[Compile with <code>g++</code>]
    B --> C[Generate Object File<br><code>my_program.o</code>]
    C --> D[Link to Executable<br><code>my_program</code>]
    D --> E[Run Program<br><code>./my_program</code>]

# Compile my_program.cpp and create an executable named 'my_program'
g++ my_program.cpp -o my_program

# Run the program
./my_program

Summary of Lesson 1:

• C++ builds upon C; much C code is valid C++.
• Use #include <iostream> for basic console I/O.
• std::cout << ...; is the standard way to print output.
• << is the stream insertion operator.
• std::endl inserts a newline and flushes the buffer.
• Namespaces (like std) prevent name conflicts. Use std:: to access names within the standard namespace.
• Compile C++ code using a C++ compiler (e.g., g++).

Next Lesson: We’ll dive deeper into C++ I/O streams, handling input with std::cin, and introduce the much more convenient std::string class compared to C-style character arrays.

More Resources:

cppreference – std::cout: https://en.cppreference.com/w/cpp/io/cout

Learn C++ – iostream Tutorial: https://www.learncpp.com/cpp-tutorial/introduction-to-iostream-cout-cin-and-endl/