Hello, C++: The Same Program in Both Languages

Bob writes C every day, and he is in a hurry to reach the STL. He copies his sum program into a file called sum.cpp and compiles it as C++. It compiles, and for the input 3 4 it prints 7. "So what changed?" he asks. Nothing yet. That is the first fact of this track: most C is already C++.

Bob's C program is already C++

Here is Bob's program, as he wrote it for the C track.

#include <stdio.h>

int main(void)
{
    int a = 0;
    int b = 0;

    scanf("%d %d", &a, &b);
    printf("%d\n", a + b);
    return 0;
}

7

That output is for the input 3 4. Bob saved the same text as sum.cpp and compiled it with g++, the C++ compiler of the GCC family that also gives you gcc. GCC 12 compiled it with no message, both at the Playground's command line and at -Wall -Wextra. It printed the same 7.

This is no accident. Bjarne Stroustrup started C++ in 1979 at Bell Labs as "C with Classes", and he kept C inside it on purpose. Your loops, arrays, functions, pointers and structs all carry over. So a C program is very nearly a C++ program. Later in this lesson you will see exactly where the "nearly" bites.

The same program in C++ words

Now the same program written the way C++ programmers write it. It reads with std::cin and prints with std::cout.

#include <iostream>

int main()
{
    int a = 0;
    int b = 0;

    std::cin >> a >> b;
    std::cout << a + b << '\n';
    return 0;
}

7

Same input, same output. Put the two programs side by side, line by line, and only four lines differ.

std::cin >> variable >> variable ... ;
std::cout << value << value ... ;

The line ends with '\n', a char that holds the newline. You will also meet std::endl in other people's code. It ends a line too, and does one more thing that costs time; lesson 02 measures it. So the C++ program prints the same 7, and only the words for reading and printing changed.

Streams: << sends, >> reads

A stream is a line of characters that flows one way, like water in a pipe. Your program has one stream coming in, standard input or stdin. It also has one going out, standard output or stdout. Stdin may be your keyboard, a file, or the Playground's input box; stdout may be the screen, a file, or a judge.

std::cin is a tap on stdin. Each >> draws the next value out of it and stores it in a variable. std::cout is a pipe into stdout, and each << pushes one value in. The arrows point the way the data flows: out of std::cin, into std::cout.

Three things that cost Bob time in C are gone. First, there is no format string. The compiler knows a is an int, so >> reads an int; make it a double and the same line reads a double. Bob's old %d against %lf mix-ups cannot happen.

Second, there is no &. std::cin receives the variable itself, not its address. The C++ feature that makes this work is the reference, and lesson 03 is about it. Third, >> skips spaces and newlines before a number, as scanf's %d does, so 3 4 on one line or on two reads the same.

The chain std::cin >> a >> b reads a first, then b. Each >> hands the stream on to the next one. << chains the same way, left to right.

Text needs one more tool. std::string is a text variable that grows by itself, from the header <string>; Module 3 teaches it properly. >> reads one word into it, up to the first space.

#include <iostream>
#include <string>

int main()
{
    std::string name;

    std::cin >> name;
    std::cout << "Hello, " << name << '\n';
    return 0;
}

Hello, Maria

That output is for the input Maria Lopez: the word stopped at the space, and Lopez stayed in the stream. So the variable's type decides what >> reads, and a word ends at a space.

std:: and using namespace std

Every name the C++ standard library gives you lives inside a namespace, a named box of names. The standard library's box is called std. So std::cout means "the cout that lives in std", and :: is the operator that looks inside a box. C has no namespaces: every name in stdio.h is simply global.

Typing std:: again and again is why much contest code starts with one extra line. Here is Bob's program with it.

#include <iostream>

using namespace std;

int main()
{
    int a = 0;
    int b = 0;

    cin >> a >> b;
    cout << a + b << '\n';
    return 0;
}

7

That output is for the input 3 4 again. using namespace std; pours every name in the box into your program. That is hundreds of names you never see, such as count, max, sort and size. Name one of your own variables the same way, and the compiler may not know which one you mean. Lesson 07 shows the message you get.

So this track has one rule. The line is fine in a short, one-file contest program, which is why you see it in so much contest code. It never goes in a header, a .h file that other files include, because then it pours std into every one of them. In this module we write std:: on every standard name, so you always see where a name comes from.

So cout after using namespace std; is the same std::cout. The only difference is how many names you let into your program.

Where C and C++ part ways on day one

Most C compiles as C++, but not all of it. Three differences meet a C programmer in the first week. Each one is shown with GCC 12's real message or output.

1. A void* does not turn into another pointer by itself. In C, malloc returns a void*, and C converts it to int* silently. This C program compiles with no message at either command line.

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int *marks = malloc(3 * sizeof(int));

    marks[0] = 72;
    printf("%d\n", marks[0]);
    free(marks);
    return 0;
}

72

Compile the same line as C++, with <cstdlib> in place of <stdlib.h>, and GCC 12 refuses it at the Playground's flags and at -Wall -Wextra.

int* marks = malloc(3 * sizeof(int));

The message is error: invalid conversion from 'void*' to 'int*' [-fpermissive]. C++ wants you to say the conversion out loud with a cast: (int*)malloc(3 * sizeof(int)). The [-fpermissive] names a flag that would turn the error back into a warning; do not use it. In practice you will rarely call malloc in C++, because Module 2's std::vector manages its own memory.

2. bool is built in. In C17, bool, true and false come from <stdbool.h>. Forget the header, and GCC 12 at -std=c17 stops.

bool passed = true;

The C compiler says error: unknown type name 'bool', then error: 'true' undeclared (first use in this function), each with a note suggesting <stdbool.h>. In C++, bool is a type of the language itself, and no header is needed.

#include <iostream>

int main()
{
    bool passed = true;

    std::cout << passed << '\n';
    return 0;
}

1

std::cout prints a bool as 1 or 0. C23 also made bool a keyword, but GCC 12's C is not C23.

3. A character literal is a char. In C, 'a' has type int. In C++, it has type char. Ask sizeof, and the two languages give different answers. Here is C.

#include <stdio.h>

int main(void)
{
    printf("%zu\n", sizeof('a'));
    return 0;
}

4

And here is C++, with one more line that shows why it matters.

#include <iostream>

int main()
{
    std::cout << sizeof('a') << '\n';
    std::cout << 'a' << ' ' << 'a' + 1 << '\n';
    return 0;
}

1
a 98

std::cout prints by type. 'a' is a char, so it prints the letter. 'a' + 1 is arithmetic, which turns the char into an int first, so it prints 98, the ASCII code of b. So in C++ a character stays a character until you do arithmetic with it.

Compiling with g++ -std=c++17

A C++ file ends in .cpp. On your own machine, compile it with g++ and name the standard: g++ -std=c++17 -Wall -Wextra sum.cpp -o sum. Then run ./sum and type the input. This track teaches C++17, the 2017 edition of the C++ standard.

On the Playground, pick C++ and the version id c++17, which is the default. The other ids are c++14 and c++20. The runner compiles with g++ -O2 -std=c++17 on GCC 12, and with no -Wall. So a warning that needs -Wall never shows up there. That is why this track always says which command line printed a message.

One newer tool is missing from our compiler. C++20's std::format builds text from a format string, like printf, but checks the types; it needs GCC 13, so not on our compiler yet. So the same .cpp file compiles on your machine and on the Playground; only the warnings you see can differ.

#include <iostream>

int main()
{
    std::cout << "Hello, C++\n";
    return 0;
}

Hello, C++

#include <iostream>

int main()
{
    int quantity = 0;
    double price = 0.0;

    std::cin >> quantity >> price;
    std::cout << quantity << " x " << price << " = " << quantity * price << '\n';
    return 0;
}

3 x 2.5 = 7.5

#include <iostream>

int main()
{
    int m1 = 0;
    int m2 = 0;
    int m3 = 0;

    std::cin >> m1 >> m2 >> m3;
    int total = m1 + m2 + m3;
    std::cout << "total: " << total << '\n';
    std::cout << "average: " << total / 3.0 << '\n';
    return 0;
}

total: 217
average: 72.3333

cout << "hello\n";

int a = 0;

std::cin << a;

int a = 0;

std::cin >> &a;

#include <iostream>

int main()
{
    std::cout << 1 << 2 << '\n';
    return 0;
}

#include <iostream>

int main()
{
    int a = 0;
    int b = 0;
    int c = 0;

    // Read the three integers with std::cin, then print them
    // in reverse order with std::cout, separated by single spaces.

    return 0;
}

#include <iostream>
#include <string>

int main()
{
    std::string name;
    int age = 0;

    // Read the name and the age with one std::cin line.
    // Print the sentence with one std::cout line.

    return 0;
}

#include <iostream>

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int n = 0;
    std::cin >> n;

    // Read the n integers. Print the largest one and its position
    // (the first integer is position 1), separated by one space.
    // If the largest appears more than once, print its first position.

    return 0;
}

Next, Kenji's correct program runs out of time on a million numbers, and lesson 02 measures the two lines that fix it.