C and C++ are general-purpose computer programming languages. They are closely related but with significant differences. This guide intends to showcase some of the features and differences of both languages in a user-friendly, progressive format. This is not a substitution for in-depth study, but should serve well as an introduction or a refresher.
Inspired by Go By Example, Haskell By Example, Dart By Example and Javascript By Example.
Check out the list of examples below to get started:
- Hello World
- Types
- Initialization
- Comments
- Switch
- Array
- Strings
- Functions
- For Loops
- While Loops
- Goto
- Integer Promotion
- Program Arguments
- Storage Class Specifiers
- Type Qualifiers
- Inline Functions
- Conditional If
- Ternary Operator
- Address Resolution Operator
- Dereference Operator
- Pointers
- Pointer Arithmetic
- Structs
- Union
- Input & Output
- Bitwise Operations
- Typedef
- Enumerations
- Variadic Functions
- Threads
- Mutex
- Heap Allocation
- Assertions
- Compound Assignment
- Project Structure
- Includes
- Compilation
C++ only:
- Modules
- Pass by Reference
- Range
- Namespaces
- Classes
- Class Methods
- Constructors & Destructors
- Encapsulation
- Inheritance
- Polymorphism
- Friend Functions
- Templates
- Structured Bindings
- Lambda Expressions
- Exception Handling
Programs:
#include <stdio.h>
int main() {
printf("Hello World!\n");
return 0;
}#include <iostream>
int main() {
std::cout << "Hello World!" << std::endl;
return 0;
}output: Hello World!
Every variable has an associated data type that defines its data storage format. Each type requires a certain amount of memory and permits a relevant set of operations.
#include <stdbool.h> //for bool
int main() {
int a; // Integer
unsigned int b; // Unsigned integers only store positive numbers. As a result, they have a higher positive range.
char c; // Character
short d; // Short integer
long e; // Long integer
float f; // Floating point integer
double g; // Double-precision floating point integer
bool h; // Boolean TRUE or FALSE
return 0;
}int main() {
int a; // Integer
unsigned int b; // Unsigned integers only store positive numbers. As a result, they have a higher positive range.
char c; // Character
short d; // Short integer
long e; // Long integer
float f; // Floating point integer
double g; // Double-precision floating point integer
bool h; // Boolean TRUE or FALSE
auto k = 1; // Automatically infer type. Not a type in itself.
return 0;
}int main() {
int a = 0;
char greeting_a[6] = {'H','e','l','l','o','\0'};
char greeting_b[] = "Hello";
char* greeting_c = "Hello";
return 0;
}#include <string>
int main() {
int a = 0; // C-like initialization
int b {0}; // Uniform initialization. Does not allow narrowing conversions.
int c(0); // Constructor initialization
char greeting_a[6] = {'H','e','l','l','o','\0'};
char greeting_b[] = "Hello";
char* greeting_c = "Hello";
std::string greeting_d = "Hello";
return 0;
}Comments are used to write notes and documentation that is to be ignored by the compiler at build time.
/*
* Multi-line comments are written like this.
*/
// Single-line comments are written like this.Jump to a matching value. Can be cleaner to write than an if/else tree.
#include <stdio.h>
int main() {
int x = 2;
switch(x) {
case 1:
printf("One");
break; // You must break the search or it will fall through to the next match.
case 2:
printf("Two");
break;
default: // If no match is found.
break;
}
return 0;
}#include <iostream>
int main() {
int x = 2;
switch(x) {
case 1:
std::cout << "One" << std::endl;
break; // You must break the search or it will fall through to the next match.
case 2:
std::cout << "Two" << std::endl;
break;
default: // If no match is found.
break;
}
return 0;
}output: Two
An array is a collection of items stored at contiguous memory locations. Elements in an array can be accessed randomly using indices.
#include <stdio.h>
int main() {
int my_array[5];
int my_array_b[] = {0,1,2,3,4}; // You can init the array from it's elements. Size can be detected automatically here.
size_t len = sizeof(my_array) / sizeof(my_array[0]);
for(size_t i = 0; i < len; i++) {
my_array[i] = i;
}
printf("%d\n", my_array[2]);
return 0;
}#include <iostream>
#include <array>
int main() {
std::array<int, 5> my_array;
for(size_t i = 0; i < my_array.size(); i++) {
my_array[i] = i;
}
std::cout << my_array[2] << std::endl;
return 0;
}output: 2
A string is an array of characters. C++ supports string types natively, but in C, a string is an array of char data, terminated with the '\0' character.
#include <stdio.h>
int main() {
char* greeting_c = "Hello";
return 0;
}#include <string>
int main() {
std::string str1 = "Hello";
return 0;
}Functions are re-usable code segments, created to perform specific tasks.
#include <stdio.h>
// Double the number passed in as 'x', returning the new value to the function caller.
int double_number_a(int x) {
return 2 * x;
}
// Double the number pointed to by 'x', storing the result in the original variable.
void double_number_b(int* x) {
*x *= 2;
}
int main() {
int num = 5;
printf("%d\n", double_number_a(num));
printf("%d\n", num);
double_number_b(&num);
printf("%d\n", num);
return 0;
}#include <iostream>
// Double the number passed in as 'x', returning the new value to the function caller.
int double_number_a(int x) {
return 2 * x;
}
// Double the number pointed to by 'x', storing the result in the original variable.
void double_number_b(int* x) {
*x *= 2;
}
int main() {
auto num = 5;
std::cout << double_number_a(num) << std::endl;
std::cout << num << std::endl;
double_number_b(&num);
std::cout << num << std::endl;
return 0;
}output: 10
5
10
Loops allow for continuous execution of a statement or group of statements, usually until a condition is met.
#include <stdio.h>
int main() {
for(int i = 1; i <= 3; i++) {
printf("%d\n", i);
}
return 0;
}#include <iostream>
int main() {
for (auto i = 1; i <= 3; i++) {
std::cout << i << std::endl;
}
return 0;
}output: 1
2
3
Loops allow continuous execution of a statement or group of statements, usually until a condition is met.
#include <stdio.h>
int main() {
int x = 1;
while(x <= 3) {
printf("%d\n", x++);
}
return 0;
}#include <iostream>
int main() {
auto x = 1;
while(x <= 3) {
std::cout << x++ << std::endl;
}
return 0;
}output: 1
2
3
Used to jump between code sections. The use of goto is contraversial as it can promote bad code decisions, but it can be very useful for avoiding large nested 'if' statements.
#include <stdio.h>
int main() {
int x;
scanf("%d", &x);
if (x < 3) goto cleanup;
// Program code here
cleanup:
return 0;
}#include <iostream>
int main() {
int x;
std::cin >> x;
if (x < 3) goto cleanup;
// Program code here
cleanup:
return 0;
}Any operand whose type ranks lower than int is temporarily promoted to int or unsigned int for comparison.
#include <stdio.h>
int main() {
char x = 'A';
if (x < 'a') printf("Less than\n"); // x is promoted to int to compare it with the integer value of 'a'.
else printf("Greater than or equal to\n");
return 0;
}#include <iostream>
int main() {
auto x = 'A';
if (x < 'a') std::cout << "Less than" << std::endl; // x is promoted to int to compare it with the integer value of 'a'.
else std::cout << "Greater than or equal to" << std::endl;
return 0;
}output: Less than
A program can optionally take a set of arguments from the user at launch.
#include <stdio.h>
int main(int argc, char* argv[]) {
for(int i = 0; i < argc; i++) {
printf("%s\n", argv[i]);
}
return 0;
}#include <iostream>
int main(int argc, char* argv[]) {
for(auto i = 0; i < argc; i++) {
std::cout << argv[i] << std::endl;
}
return 0;
}input: ./program arg1 arg2
output: program
arg1
arg2
Define the storage duration of an object.
int main() {
extern int a; // defined elsewhere
static int b; // hold value between invocations
register int c; // store in CPU register for fast access
auto int d; // automatic duration - scope lifetime. Implicit if not specified
_Thread_local int e; // thread storage duration
return 0;
}int main() {
extern int a; // defined elsewhere
register int c; // automatic storage duration. Also hints to the compiler to place the object in the processor's register
static int b; // hold value between invocations
thread_local int e; // thread storage duration
return 0;
}A way of expressing additional information about a value through the type system to ensure correctness in the use of the data.
int main() {
restrict int* a; // Should only be accessed from this pointer
const int b; // Once defined, is constant and cannot be changed
atomic int c; // Can only be modified by one thread at a time
volatile int d; // Can be modified externally. the program will check x's value before using it, even if it hasn't been modified locally.
return 0;
}#include <atomic>
int main() {
const int a = 1; // a, once defined, is constant and cannot be changed
std::atomic<int> b; // b can only be modified by one thread at a time
volatile int c; // c can be modified externally. the program will check x's value before using it, even if it hasn't been modified locally.
return 0;
}Directly include the given function in the caller code sequence. This ensures that: function call overhead doesn’t occur ; overhead of push/pop variables on the stack is eliminated ; overhead of the return call is eliminated ; context-specific optimizations can be enabled at compile time.
#include <stdio.h>
static inline void square(int* x) {
*x *= *x;
return;
}
int main() {
int num = 5;
square(&num);
printf("%d\n", num);
return 0;
}#include <iostream>
inline void square(int& x) {
x *= x;
return;
}
int main() {
int num = 5;
square(num);
std::cout << num << std::endl;
return 0;
}output: 25
Responsible for modifying the flow of execution in a program. Always used with a condition, which is evaluated first before executing any statement inside the body.
#include <stdio.h>
int main() {
int x = 4;
if (!x) printf("x is 0\n"); // one line if statement
else if (x < 0) printf("x is negative\n");
else { // or you can use a block
printf("x is positive\n");
}
return 0;
}#include <iostream>
int main() {
if (int x = 4 ; !x) std::cout << "x is 0" << std::endl; // one line if statement with optional init statement before condition
else if (x < 0) std::cout << "x is negative" << std::endl;
else { // or you can use a block
std::cout << "x is positive" << std::endl;
}
return 0;
}output: x is positive
A conditional operator that provides a shorter syntax for the if statement. The first operand is a boolean expression; if the expression is true then the value of the second operand is returned otherwise the value of the third operand is returned.
#include <stdio.h>
int main() {
int x = 4;
x < 0 ? printf("x is negative\n") : printf("x is 0 or positive\n");
return 0;
}#include <iostream>
int main() {
int x = 4;
x < 0 ? std::cout << "x is negative" << std::endl : std::cout << "x is 0 or positive" << std::endl;
return 0;
}Use '&' before a variable name to use it's address in memory rather than the value stored.
#include <stdio.h>
int main() {
int x = 5;
printf("The address of x is %p\n", (void*)&x);
return 0;
}#include <iostream>
int main() {
int x = 5;
std::cout << "The address of x is " << &x << std::endl;
return 0;
}output: The address of x is 0x7ffd7b254c2c
Use '*' before a variable name to use the value it points to rather than the address stored.
#include <stdio.h>
int main() {
int x = 4;
int* y = &x;
printf("The value stored at x is %d\n", *y);
return 0;
}#include <iostream>
int main() {
int x = 4;
int* y = &x;
std::cout << "The value stored at x is " << *y << std::endl;
return 0;
}output: The value stored at x is 4
A pointer is a variable that can hold the address of another variable. Just like regular data types, they must have their own type which refers to the type of the data at the address pointed to.
#include <stdio.h>
int main() {
int* x; // pointer to type int
return 0;
}#include <iostream>
int main() {
int* x; // pointer to type int
return 0;
}Perform integer addition or subtraction operations on pointers, taking the data type's size into account to return the correct address of the next item.
#include <stdio.h>
int main() {
int x[5];
int* x_ptr = &x[0];
printf("Value of x_ptr = %p\n", (void*)x_ptr);
printf("Value of x_ptr + 1 = %p\n", (void*)(x_ptr + 1));
char y[5];
char* y_ptr = &y[0];
printf("Value of y_ptr = %p\n", (void*)y_ptr);
printf("Value of y_ptr + 1 = %p\n", (void*)(y_ptr + 1));
return 0;
}#include <iostream>
int main() {
int x[5];
int* x_ptr = &x[0];
std::cout << "Value of x_ptr = " << x_ptr << std::endl;
std::cout << "Value of x_ptr + 1 = " << x_ptr + 1 << std::endl;
char y[5];
char* y_ptr = &y[0];
std::cout << "Value of y_ptr = " << y_ptr << std::endl;
std::cout << "Value of y_ptr + 1 = " << y_ptr + 1 << std::endl;
return 0;
}Output: Value of x_ptr = 492316
Value of x_ptr + 1 = 492320
Value of y_ptr = 492303
Value of y_ptr + 1 = 492304
Structs are user defined data storage objects containing public members by default.
#include <stdio.h>
struct my_struct {
int x;
int y;
};
int main() {
struct my_struct object1;
object1.x = 1;
printf("%d\n", object1.x);
return 0;
}#include <iostream>
struct my_struct {
int x;
int y;
};
int main() {
struct my_struct object1;
object1.x = 1;
std::cout << object1.x << std::endl;
return 0;
}output: 1
A union is a special data type that can store different data types at the same memory location. You can define a union with many members, but only one member can contain a value at any given time. Unions provide an efficient way of using the same memory location for multiple purposes. A union's size will be the size of the largest constituent type.
#include <stdio.h>
union my_data {
int i;
float f;
char str[20];
};
int main() {
union my_data object1;
printf("Size of my_data union: %lu\n", sizeof(object1));
return 0;
}#include <iostream>
union my_data {
int i;
float f;
char str[20];
};
int main() {
union my_data object1;
std::cout << "Size of my_data union: " << sizeof(object1) << std::endl;
return 0;
}Output: Size of my_data union: 20
In C, interacting with the user console is made possible through the stdio.h (standard input output library) header, which contains methods for input and output. C++ provides a convenient abstraction built into the iostream header, known as streams, to perform input and output operations in sequential media such as the screen, the keyboard or a file. A stream is an entity that a program can use to either insert or extract data.
#include <stdio.h>
int main() {
int x;
printf("Enter an integer value for x: ");
scanf("%d", &x);
printf("The value at x is now: %d\n", x);
return 0;
}#include <iostream>
int main() {
int x;
std::cout << "Enter an integer value for x: ";
std::cin >> x;
std::cout << "The value at x is now: " << x << std::endl;
return 0;
}output: Enter an integer value for x: 6
The value at x is now: 6
Bitwise operators are used to perform bit-level operations.
#include <stdio.h>
int main() {
unsigned char a = 5; // 00000101
unsigned char b = 9; // 00001001
printf("a & b = %d\n", a & b); // 00000001
printf("a | b = %d\n", a | b); // 00001101
printf("a ^ b = %d\n", a ^ b); // 00001100
printf("~a = %d\n", a = ~a); // 11111010
printf("b << 1 = %d\n", b << 1); // 00010010
printf("b >> 1 = %d\n", b >> 1); // 00000100
return 0;
}#include <iostream>
int main() {
unsigned char a = 5; // 00000101
unsigned char b = 9; // 00001001
std::cout << "a & b = " << (a & b) << std::endl; // 00000001
std::cout << "a | b = " << (a | b) << std::endl; // 00001101
std::cout << "a ^ b = " << (a ^ b) << std::endl; // 00001100
std::cout << "~a = " << (~a) << std::endl; // 11111010
std::cout << "b << 1 = " << (b << 1) << std::endl; // 00010010
std::cout << "b >> 1 = " << (b >> 1) << std::endl; // 00000100
return 0;
}output: a & b = 1
a | b = 13
a ^ b = 12
~a = -6
b << 1 = 18
b >> 1 = 4
Used to add an additional name to a type. Useful when working with more complex types, making them more human readable.
#include <stdio.h>
typedef unsigned char byte;
int main() {
byte b1 = 'c';
return 0;
}#include <iostream>
typedef unsigned char byte;
int main() {
byte b1 = 'c';
return 0;
}A user-defined data type, used to assign names to integral constants to make a program easier to read and maintain.
#include <stdio.h>
enum week {
mon,
tue,
wed,
thu,
fri,
sat,
sun
};
int main() {
for(int i = mon; i <= sun; i++) {
printf("%d\n", i);
}
return 0;
}#include <iostream>
enum week {
mon,
tue,
wed,
thu,
fri,
sat,
sun
};
int main() {
for(int i = mon; i <= sun; i++) {
std::cout << i << std::endl;
}
return 0;
}output: 0
1
2
3
4
5
6
Create a function with an arbitrary argument count for more flexibility.
#include <stdio.h>
#include <stdarg.h>
int sum(int count, ...)
{
int total, i, temp;
total = 0;
va_list args;
va_start(args, count);
for(int i = 0; i < count; i++) {
temp = va_arg(args, int);
total += temp;
}
va_end(args);
return total;
}
int main() {
int numbers[3] = {5, 10, 15};
int sum_of_numbers = sum(3, numbers[0], numbers[1], numbers[2]);
printf("Sum of the array: %d\n", sum_of_numbers);
return 0;
}#include <iostream>
#include <cstdarg>
int sum(int count, ...)
{
int total, i, temp;
total = 0;
va_list args;
va_start(args, count);
for(int i = 0; i < count; i++) {
temp = va_arg(args, int);
total += temp;
}
va_end(args);
return total;
}
int main() {
int numbers[3] = {5, 10, 15};
int sum_of_numbers = sum(3, numbers[0], numbers[1], numbers[2]);
std::cout << "Sum of the array: " << sum_of_numbers << std::endl;
return 0;
}output: Sum of the array: 30
Used to execute one or more subthreads to allow for parallel processing in the same memory space, usually resulting in a performance improvement in a larger program.
#include <stdio.h>
#include <threads.h>
int thread_func(void* arg) {
printf("Printing from Thread\n");
return NULL;
}
int main() {
thrd_t thread_id;
thrd_create(&thread_id, thread_func, NULL);
thrd_join(thread_id, NULL); // Wait for thread to return before continuing execution
printf("Thread returned\n");
return 0;
}#include <iostream>
#include <thread>
void thread_func() {
std::cout << "Printing from Thread" << std::endl;
return NULL;
}
int main() {
std::thread thread_obj(thread_func);
thread_obj.join();
std::cout << "Thread returned" << std::endl;
return 0;
}output: Printing from Thread
Thread returned
Mutual exclusion functionality. Can be used to serialize access of shared variables between concurrent threads.
#include <stdio.h>
#include <threads.h>
typedef struct data {
mtx_t mtx;
int x;
} data;
int thread_func(void* arg) {
data* d = (data*)arg;
mtx_lock(&d->mtx);
d->x = 2;
mtx_unlock(&d->mtx);
return 0;
}
int main() {
data d;
mtx_init(&d.mtx, mtx_plain);
thrd_t thread_id;
thrd_create(&thread_id, thread_func, (void*)&d);
thrd_join(thread_id, NULL); // Wait for thread to return before continuing execution
printf("x has safely been modified to %d\n", d.x);
return 0;
}#include <iostream>
#include <thread>
#include <mutex>
typedef struct data {
std::mutex mtx;
int x;
} data;
void thread_func(data* d) {
d->mtx.lock()
d->x = 2;
d->mtx.unlock()
return;
}
int main() {
data d;
std::thread thread_obj(thread_func, &d);
thread_obj.join(); // Wait for thread to return before continuing execution
std::cout << "x has safely been modified to " << d.x << std::endl;
return 0;
}Memory can be allocated on the heap, an unreserved and relatively large region of memory outside of the program's memory scope.
#include <stdio.h>
#include <stdlib.h>
int main() {
int* x = (int*)malloc(sizeof(int)); // pointer to a heap-reserved integer
if (x) { // test that the memory was allocated before you use it
free(x); // you must manually free any memory you allocated on the heap or it will persist (memory leak)
}
return 0;
}#include <iostream>
int main() {
int* p = new int; // pointer to a heap-reserved integer
delete p; // you must manually free any memory you allocated on the heap or it will persist (memory leak)
return 0;
}Statements used to explicitly test assumptions made by the programmer. Will be checked at runtime, or if static at compile time. Typically used for unit testing.
#include <stdio.h>
#include <assert.h>
int main() {
int x = 1;
assert(x == 2); // this should break the execution of the program
return 0;
}#include <assert.h>
int main() {
int x = 1;
assert(x == 2); // this should break the execution of the program
return 0;
}output: int main(): Assertion `x == 2' failed.
Provides a shorter syntax for assigning the result of an arithmetic or bitwise operator by performing an operation on the two operands before assigning the result to the first operand.
#include <stdio.h>
int main() {
int x = 1;
x += 1;
printf("x = %d\n", x);
return 0;
}#include <iostream>
int main() {
int x = 1;
x += 1;
std::cout << "x = " << x << std::endl;
return 0;
}output: x = 2
It's useful to follow a conventional and sensible structure when organizing a project, to maintain readability. Below is a suggestion as to how you might organize your project.
doc/ Only for software user guide
src/ Only for code: .c and .h files. May also contain a contrib/ directory.
test/ Only for integration and unit tests
Makefile Makefile
Style.md C style guide
_opt/ Everything else that is not required to build/test. Developer notes, scripts, linters, ci stuff, analysis tools etc.
doc/ Only for software user guide
src/ Only for code: .cpp and .h files. May also contain a contrib/ directory.
test/ Only for integration and unit tests
Makefile Makefile
Style.md C++ style guide
_opt/ Everything else that is not required to build/test. Developer notes, scripts, linters, ci stuff, analysis tools etc.
Includes are instructions to the preprocessor to include external code. External code is made up of at least a header file (interface) and a source file (implementation).
When compiling your program, #include the header, and link the source file at compile time.
In file src/main.c
#include <stdio.h> // Include a dependency from the system library
#include "../include/file.h" // Include a local dependency from a relative path
int main() {
// Use file.h
}In file include/file.c:
#include <stdio.h> // Include a dependency from the system library
#include "file.h" // Include a local dependency from a relative pathIn file include/file.h:
#ifndef PROG_H // Only process the below if it hasn't already been processed in the current compilation.
#define PROG_H
// File contents here
#endifIn file src/main.cpp
#include <iostream> // Include a dependency from the system library
#include "../include/file.hpp" // Include a local dependency from a relative path
int main() {
// Use file.hpp
}In file include/file.cpp:
#include <iostream> // Include a dependency from the system library
#include "file.hpp" // Include a local dependency from a relative pathIn file include/file.hpp:
#ifndef PROG_HPP // Only process the below if it hasn't already been processed in the current compilation.
#define PROG_HPP
// File contents here
#endifCompiling source code turns it into machine language through preprocessing, compiling, assembly and linking.
gcc -c -std=c17 src/main.c -o obj/main.o // Compile main.c to object
gcc -c -std=c17 include/file.c -o obj/file.o // Compile file.c to object
gcc obj/main.o obj/file.o -o bin/prog // Link objects and create executable bin/prog
g++ -c -std=c++20 src/main.cpp -o obj/main.o // Compile main.cpp to object
g++ -c -std=c++20 include/file.cpp -o obj/file.o // Compile file.cpp to object
g++ obj/main.o obj/file.o -o bin/prog // Link objects and create executable bin/prog
Modules are a new method in C++ to allow for better package management and easier library integration.
In file foo.cpp:
export module Foo;
namespace Bar {
int f_internal() {
return 10;
}
export int f() {
return f_internal();
}
}In file main.cpp:
import std;
import Foo;
int main() {
std::cout << Bar::f() << std::endl;
return 0;
}output: 10
Use the & symbol as an alternative to passing an address by pointer or passing by value.
#include <iostream>
void square(int& x) {
x *= x;
return;
}
int main() {
int x = 2;
square(x);
std::cout << x << std::endl;
return 0;
}output: 4
Used as a more readable equivalent to a traditional loop when iterating over a range of data.
#include <iostream>
#include <vector>
int main() {
std::vector<int> v = {0, 1, 2, 3};
for(const int& i : v) { // access using const reference
std::cout << i << std::endl;
}
int a[] = {4, 5, 6, 7};
for(auto n : a) { // the initializer can be an array
std::cout << n << std::endl;
}
return 0;
}output: 0
1
2
3
4
5
6
7
A declarative region that provides a named scope to its constituent identifiers. Useful for organizing and reducing ambiguity in code. The scope resolution operator :: is used to access a scope's contents.
#include <iostream>
namespace ns_1 {
void func() {
std::cout << "Called from ns_1" << std::endl;
}
}
namespace ns_2 {
void func() {
std::cout << "Called from ns_2" << std::endl;
}
}
int main () {
ns_1::func();
ns_2::func();
return 0;
}output: Called from ns_1
Called from ns_2
A user-defined data structure template declared with keyword class containing member functions and data.
#include <iostream>
class human {
public:
int height;
int weight;
};
int main() {
human john;
john.height = 180;
john.weight = 220;
return 0;
}Functions of a class.
#include <iostream>
class human {
public:
int height;
int weight;
int get_height() const {
return height;
}
int get_weight() const {
return weight;
}
};
int main() {
human john;
john.height = 180;
john.weight = 220;
std::cout << john.get_height() << std::endl;
std::cout << john.get_weight() << std::endl;
return 0;
}output: 180
220
A constructor is an optional special member function of a class used to instantiate the class object. It must take the same name as the class, with no return type. A destructor is an optional special member function of a class called in the destruction of a class object. It must take the same name as the class, preceded with ~, and with no return type.
#include <iostream>
class human {
public:
int height;
int weight;
human(int h, int w) {
height = h;
weight = w;
}
~human(){};
int get_height() const {
return height;
}
int get_weight() const {
return weight;
}
};
int main() {
human john(180, 220);
std::cout << john.get_height() << std::endl;
std::cout << john.get_weight() << std::endl;
return 0;
}output: 180
220
Fundamental OOP concept used to group together data and functions, and provide varying levels of abstraction from the user.
#include <iostream>
class human {
private: // abstracted from the user
int height;
int weight;
public:
human(int h, int w) {
height = h;
weight = w;
}
int get_height() const {
return height;
}
int get_weight() const {
return weight;
}
};
int main() {
human john(180, 220);
std::cout << john.get_height() << std::endl;
std::cout << john.get_weight() << std::endl;
return 0;
}output: 180
220
Fundamental OOP concept. The capability of a class to derive properties and characteristics from another class.
#include <iostream>
class human {
public:
int height;
int weight;
public:
human(int h, int w) {
height = h;
weight = w;
}
int get_height() const {
return height;
}
int get_weight() const {
return weight;
}
};
class adult : public human { // inherit from human class
public:
adult(int h, int w) : human(h, w) {} // call the base class constructor from this constructor
std::string occupation;
std::string get_occupation() const {
return occupation;
}
};
int main() {
adult john(180, 220);
john.occupation = "lawyer";
std::cout << john.get_height() << std::endl;
std::cout << john.get_weight() << std::endl;
std::cout << john.get_occupation() << std::endl;
return 0;
}output: 180
220
lawyer
Fundamental OOP concept. Allows operations or objects to behave differently in different contexts.
Used to facilitate compile-time polymorphism by allowing creation of more than one function with the same name but with different parameters.
#include <iostream>
class human {
public:
int height;
float weight;
human(int h, int w) {
height = h;
weight = w;
}
};
int print(int x) {
std::cout << x << std::endl;
}
int print(float x) {
std::cout << x << std::endl;
}
int main() {
human john(180, 220);
print(john.height);
print(john.weight);
return 0;
}output: 180
220
Used to facilitate runtime polymorphism by allowing redefinition of a base class function.
#include <iostream>
class human {
public:
int height;
int weight;
public:
human(int h, int w) {
height = h;
weight = w;
}
int get_height() const {
return height;
}
int get_weight() const {
return weight;
}
virtual void print_all() = 0; // ()=0 creates a _pure_ virtual function that must be overridden. Alternatively you can just write a default function as a virtual function with no requirement to be overwritten.
};
class adult : public human { // inherit from human class
public:
adult(int h, int w) : human(h, w) {}
std::string occupation;
std::string get_occupation() const {
return occupation;
}
void print_all() { // virtual function overridden in derived class
std::cout << height << std::endl;
std::cout << weight << std::endl;
std::cout << occupation << std::endl;
}
};
int main() {
adult john(180, 220);
john.occupation = "lawyer";
john.print_all();
return 0;
}output: 180
220
lawyer
A function of a class defined outside of its scope but with the right to access all private and protected members of the class.
#include <iostream>
class human {
private:
int weight;
public:
human(int w) {
weight = w;
}
friend int get_weight(human h);
};
int get_weight(human h) {
return h.weight; // we can access the private members of the associated class thanks to the friend function
}
int main() {
human john(220);
std::cout << get_weight(john) << std::endl;
return 0;
}output: 220
A blueprint for creating a generic class or function. The foundation of generic programming, which involves writing code in a way that is independent of any particular type.
#include <iostream>
template <class T>
T largest(T n1, T n1) {
return (n1 > n2) ? n1 : n2;
}
int main() {
int x, y;
std::cout << "Enter two integers: " << std::endl;
std::cin >> x >> y;
std::cout << largest(x, y) << std::endl;
return 0;
}input: 2
5
output: 5
A convenient way to declare multiple variables initialized from a tuple, pair or struct. Often used to capture multiple return values from a function.
#include <iostream>
struct Point {
int x;
int y;
};
int main() {
Point p = {1, 2};
auto[x, y] = p; // Creates and initializes x and y variables
std::cout << x << std::endl;
std::cout << y << std::endl;
return 0;
}output: 1
2
Also referred to as Lambda Functions. A simplified notation for defining and using an anonymous function object, capable of capturing variables in scope.
#include <iostream>
int main() {
int x = 1;
auto multiply = [&x](int y)->int{ // Anonymous function takes a reference to x. Returns an int
return x*y;
};
std::cout << multiply(5) << std::endl;
x = 2;
std::cout << multiply(5) << std::endl;
return 0;
}output: 5
10
A mechanism to handle runtime errors by transferring control from one part of a program to another.
#include <iostream>
double divide(double dividend, double divisor) {
if (divisor == 0) {
throw "Cannot divide by 0\n"; // If divisor is 0, throw this error
}
return dividend / divisor;
}
int main() {
try {
std::cout << divide(10, 0) << std::endl;
} catch (const char *err) {
std::cout << err << std::endl;
}
return 0;
}output: Cannot divide by 0
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node* next;
};
struct Node* createNode(int data) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->next = NULL;
return newNode;
}
void push_front(struct Node** headRef, int data) {
struct Node* newNode = createNode(data);
newNode->next = *headRef;
*headRef = newNode;
}
void push_back(struct Node** headRef, int data) {
struct Node* newNode = createNode(data);
newNode->next = NULL;
if (*headRef == NULL) {
*headRef = newNode;
return;
}
struct Node* curr = *headRef;
while (curr->next != NULL) {
curr = curr->next;
}
curr->next = newNode;
}
void printList(struct Node* head) {
struct Node* curr = head;
while (curr != NULL) {
printf("%d -> ", curr->data);
curr = curr->next;
}
printf("NULL\n");
}
int main() {
struct Node* head = NULL;
push_back(&head, 1);
push_back(&head, 2);
push_back(&head, 3);
push_back(&head, 4);
push_front(&head, 5);
printList(head);
return 0;
}#include <iostream>
#include <list>
int main() {
std::list<int> myList;
myList.push_back(1);
myList.push_back(2);
myList.push_back(3);
myList.push_back(4);
myList.push_front(5);
for (auto it = myList.begin(); it != myList.end(); ++it) {
std::cout << *it << " -> ";
}
std::cout << "NULL" << std::endl;
return 0;
}output: 5 -> 1 -> 2 -> 3 -> 4 -> NULL
#include <stdio.h>
#include <stdlib.h>
typedef struct Node {
int data;
struct Node *left;
struct Node *right;
} Node;
Node* create_node(int data) {
Node* node = (Node*) malloc(sizeof(Node));
node->data = data;
node->left = NULL;
node->right = NULL;
return node;
}
Node* insert_node(Node* node, int data) {
if (node == NULL) {
return create_node(data);
} else if (data < node->data) {
node->left = insert_node(node->left, data);
} else if (data > node->data) {
node->right = insert_node(node->right, data);
}
return node;
}
void inorder_traversal(Node* node) {
if (node != NULL) {
inorder_traversal(node->left);
printf("%d ", node->data);
inorder_traversal(node->right);
}
}
int main() {
Node* root = NULL;
root = insert_node(root, 50);
insert_node(root, 30);
insert_node(root, 20);
insert_node(root, 40);
insert_node(root, 60);
insert_node(root, 10);
inorder_traversal(root);
return 0;
}#include <iostream>
#include <memory>
struct Node {
int data;
std::unique_ptr<Node> left, right;
Node(int value) : data(value) {}
};
class BinarySearchTree {
public:
BinarySearchTree() = default;
std::unique_ptr<Node> insert_node(std::unique_ptr<Node> node, int value) {
if (!node) {
return std::make_unique<Node>(value);
}
if (value < node->data) {
node->left = insert_node(std::move(node->left), value);
} else if (value > node->data) {
node->right = insert_node(std::move(node->right), value);
}
return node;
}
void inorder_traversal(Node* node) {
if (node) {
inorder_traversal(node->left.get());
std::cout << node->data << " ";
inorder_traversal(node->right.get());
}
}
std::unique_ptr<Node> root = nullptr;
};
int main() {
BinarySearchTree bst;
bst.root = bst.insert_node(std::move(bst.root), 50);
bst.root = bst.insert_node(std::move(bst.root), 30);
bst.root = bst.insert_node(std::move(bst.root), 20);
bst.root = bst.insert_node(std::move(bst.root), 40);
bst.root = bst.insert_node(std::move(bst.root), 60);
bst.root = bst.insert_node(std::move(bst.root), 10);
bst.inorder_traversal(bst.root.get());
std::cout << std::endl;
return 0;
}output: 10 20 30 40 50 60
Copy a file from source to destination. Note that memory-mapped I/O can be more efficient for large files, but it requires more advanced knowledge of the operating system and may not be available on all platforms.
#include <stdio.h>
int main() {
FILE *source_file, *destination_file;
char buffer[4096];
size_t bytes_read;
source_file = fopen("source.txt", "rb");
destination_file = fopen("destination.txt", "wb");
if (source_file == NULL || destination_file == NULL) {
printf("Error opening files.\n");
return 1;
}
while ((bytes_read = fread(buffer, 1, sizeof(buffer), source_file)) > 0) {
fwrite(buffer, 1, bytes_read, destination_file);
}
fclose(source_file);
fclose(destination_file);
return 0;
}#include <fstream>
#include <iostream>
int main() {
const std::string source = "source.txt";
const std::string destination = "destination.txt";
std::ifstream input(source, std::ios::binary);
std::ofstream output(destination, std::ios::binary);
if (!input.is_open()) {
std::cerr << "Failed to open source file.\n";
return 1;
}
if (!output.is_open()) {
std::cerr << "Failed to open destination file.\n";
return 1;
}
output << input.rdbuf();
input.close();
output.close();
return 0;
}output:
#include <stdio.h>
#include <stdlib.h>
#include <threads.h>
#define BUFFER_SIZE 4
int buffer[BUFFER_SIZE];
int count = 0;
mtx_t mutex;
cnd_t cv;
int producer(void *arg) {
int i;
for (i = 0; i < BUFFER_SIZE; i++) {
mtx_lock(&mutex);
while (count == BUFFER_SIZE) {
cnd_wait(&cv, &mutex);
}
buffer[count] = i;
count++;
cnd_signal(&cv);
mtx_unlock(&mutex);
}
return 0;
}
int consumer(void *arg) {
while (1) {
mtx_lock(&mutex);
while (count == 0) {
cnd_wait(&cv, &mutex);
}
int message = buffer[count - 1];
count--;
cnd_signal(&cv);
mtx_unlock(&mutex);
printf("Received message: %d\n", message);
}
}
int main() {
mtx_init(&mutex, mtx_plain);
cnd_init(&cv);
thrd_t producer_thread, consumer_thread;
thrd_create(&producer_thread, producer, NULL);
thrd_create(&consumer_thread, consumer, NULL);
thrd_join(producer_thread, NULL);
thrd_join(consumer_thread, NULL);
mtx_destroy(&mutex);
cnd_destroy(&cv);
return 0;
}#include <iostream>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
std::mutex mutex;
std::queue<int> message_queue;
std::condition_variable cv;
void producer() {
for (int i = 0; i < 4; i++) {
std::lock_guard<std::mutex> lock(mutex);
message_queue.push(i);
cv.notify_one();
}
}
void consumer() {
while (true) {
std::unique_lock<std::mutex> lock(mutex);
cv.wait(lock, []{ return !message_queue.empty(); });
int message = message_queue.front();
message_queue.pop();
lock.unlock();
std::cout << "Received message: " << message << std::endl;
}
}
int main() {
std::thread producer_thread(producer);
std::thread consumer_thread(consumer);
producer_thread.join();
consumer_thread.join();
return 0;
}output: Received message: 0
Received message: 1
Received message: 2
Received message: 3
Copyright © 2023 Sean Valeo | Source | Contributors