Multi-Paradigm

Proper implementation of multiple programming paradigms

• Procedural programming
• Object-Oriented programming (OOP)
• Generic programming
• Functional programming

High-Level Programming

The standard library provides algorithms and containers allowing the programmer to focus on the problem.

• array, list, map, set, string, vector, ... - see containers library
• algorithms are provided in the algorithms and numerics libraries

• Low-level programming close to the hardware is possible (like in C)
• High performance (fast execution speed)
• Exception handling, namespaces, ...
• Large community (TIOBE Index, Open Hub Language Comparison)
  • Open source compilers and tools
  • Abundance of resources for learning
  • Ever-evolving

C++ is not a strict superset of C.

Code that is valid C is not automatically valid C++.

Example

#include <stdio.h>

int main() {
  int new = 3;
  printf("%d\n", new);
  return 0;
}

Download valid_c.c

Wikipedia has more information on compatibility of C and C++

#include <iostream>

/* Hello World program written in C++. */
int main(void) {
  std::cout << "Hello, World!" << std::endl;  // output some text
  return 0;  // 0 means success
}

Visualize execution

Preprocessor Directives

Allow to include code declared elsewhere

#include <iostream>

/* Hello World program written in C++. */
int main(void) {
  std::cout << "Hello, World!" << std::endl;  // output some text
  return 0;  // 0 means success
}

Comments

// single line comment
int x = 5;  // comments can be added at the end of a line

/*
 * multiline comment
 * ...
 */

Main Function

Serves a special purpose in C++ programs:
program execution begins with main(.)

#include <iostream>

/* Hello World program written in C++. */
int main(void) {
  std::cout << "Hello, World!" << std::endl;  // output some text
  return 0;  // 0 means success
}

Return Value

Indicate success (0) or a failure code to the calling operating system shell

#include <iostream>

/* Hello World program written in C++. */
int main(void) {
  std::cout << "Hello, World!" << std::endl;  // output some text
  return 0;  // 0 means success
}

Executable program files are created from readable source code.

main.cpp

→

executable

Creating a C++ executable is a four step process.

1. Preprocessor
2. Compiler
3. Assembler
4. Linker

Example

Download hello.cpp

By default, all four stages (preprocessor, compiler, assembler and linker)
are done

clang++ hello.cpp  # or `g++ hello.cpp`
./a.out

clang++ hello.cpp -o hello
./hello

clang++ $INFILE -o $PROGRAM_NAME
g++ $INFILE -o $PROGRAM_NAME

1. Preprocessor

• Essentially a pure text processor
• Removes comments, performs includes etc.
• Usually never done separately

clang++ -E hello.cpp

2. Compiler

• Translates high level code to a lower level (assembly language)
• Parses the source code
• Performs type checking
• Usually never done separately
• Must recognize all identifiers (function declarations etc.)

clang++ -S hello.cpp

3. Assembler

• Translates assembly language to object code (machine language)
• Creates *.o files
• Usually done separately when working with multiple input files
  • Impossible to create executables without main(.)
  • Impossible to create executables with multiple main(.)

clang++ -c hello.cpp

4. Linker

• Combines object files into a unified executable program, resolving all symbols
• Should be run separately when working with multiple input files

clang++ -o hello hello.o