Skip to content

Latest commit

 

History

History
422 lines (339 loc) · 9.9 KB

cpp.md

File metadata and controls

422 lines (339 loc) · 9.9 KB
title description created updated
C++ Programming language
C++ Programming language cheatsheet contains useful code syntax with examples which is handy while coding.
2020-04-30
2020-04-30

C++ is a widely used middle-level programming language which is used in developing major operating systems( Windows, Linux, Android, Ubuntu, iOS etc), Games, databases and compilers etc.

Basics

  • cin >> x: read value into the variable x from input stream
  • cout << x: printf value to the output stream
  • //: single line comments
  • /* */: Multi line comments
#include <iostream>
using namespace std;
int main() {
    cout << "Hello World!!";
    return 0;
}  
  • #include <iostream>: iostream is a inbuilt header library which allows you to deal with input and output objects like cout etc.
  • using namespace std: Specifies that the object and variable names can be used from standard library.
  • cin: to accept input from standard input device i.e keyboard.
  • cout: to print the output.
  • main(): main function is the entry point of any C++ program.
  • return 0: To end the main function

How to compile a program in C++

Open your terminal, Navigate to the directory where you have saved your program. Consider firstprogram.cpp is the name of your program.

sudo g++ -o firstprogram firstprogram.cpp

How to run a C++ program

./firstprogram

Data types

Types Data-type
Basic int, char, float, double, short, short int, long int etc
Derived array, pointer etc
User Defined Data Type structure, enum, Class, Union, Typedef

Variables

data-type variable-name = value;
int value = 10; // declaring int variable and assigning value 10 to it
char grade = 'A'; // declaring char variable and assigning value A to it

Naming convention

  • only letters (both uppercase and lowercase letters), digits and underscore(_).
  • cannot contain white spaces
  • First letter should be either a letter or an underscore(_).
  • Variable type can't be changed
  • Case sensitive

Arrays

data-type array-name[size]; // one-dimensional Array
data-type array-name[size][size]; // two-dimensional Array

Example:

int a[5] = {1,2,3,4,5};
int a[2][3] = {
                {1,2,3},
                {4,5,6}
              };

Literals or Constants

Literal Example
Integer Literal- decimal 255
Integer Literal- octal 0377
Integer Literal- hexadecimal 0xFF
Float point Literal 53.0f, 79.02
Character literals 'a', '1'
String literals "OneCompiler", "Foo"

Escape sequences

Escape sequence Description
\n New line
\r Carriage Return
? Question mark
\t Horizontal tab
\v Vertical tab
\f Form feed
\ Backslash
' Single quotation
" Double quotation
\0 Null character
\b Back space

Operators

Operator type Description
Arithmetic Operator + , - , * , / , %
comparision Operator < , > , <= , >=, != , ==
Bitwise Operator & , ^ ,
Logical Operator && , ||, !
Assignment Operator = , += , -= , *= , /= , %=, <<=, >>=, &=, ^=, |=
Ternary Operator ? :
sizeof operator sizeof()

Conditional Statements

1. If

if(conditional-expression)
{
    //code
}

2. If-else

if(conditional-expression)
{
    //code
} else {
    //code
}

3. If-else-if ladder

if(conditional-expression-1)
{
    //code
} else if(conditional-expression-2) {
    //code
} else if(conditional-expression-3) {
    //code
}
....
else {
    //code
}

4. Switch

switch(conditional-expression){    
case value1:    
 //code    
 break;  //optional  
case value2:    
 //code    
 break;  //optional  
...    
    
default:     
 //code to be executed when all the above cases are not matched;    
} 

Loops

1. For

for(Initialization; Condition; Increment/decrement){  
//code  
} 

2. While

while(condition){  
//code 
}  

3. Do-While

do{  
//code 
} while(condition); 

Functions

Function is a sub-routine which contains set of statements.

// declaring a function
return_type function_name(parameters);

// defining a function
return_type function_name(parameters){  
//code
}

// calling a function
function_name (parameters)

Pointers

Pointer is a variable which holds the memory information(address) of another variable of same data type.

datatype *pointername;

Example

int x = 10, *ptr;

/*ptr = x; // Error because ptr is adress and x is value
*ptr = &x;  // Error because x is adress and ptr is value */

ptr = &x; // valid because &x and ptr are addresses
*ptr = x; // valid because both x and *ptr values 

Structures

Structure is a user-defined data type where it allows you to combine data of different data types.

struct structure_name {

   member definition;
   member definition;
   ...
   member definition;
} [one or more structure variables]; 

struct structure_name variable name; //declaring structure variables

Classes

A class in C++ is the building block that leads to Object-Oriented programming. It is a user-defined data type, which holds its own data members and member functions, which can be accessed and used by creating an instance of that class. A C++ class is like a blueprint for an object.

class MyClass {       // The class
  public:             // Access specifier
    int myNum;        // Attribute (int variable)
    string myString;  // Attribute (string variable)
};

Enum

Enumeration data type is a user-defined data type in C++. enum keyword is used to declare a new enumeration types in C++.

enum name{constant1, constant2, constant3, ....... } var-list;

Example

enum month{January, February, March, April, May, June, July, August, September, October, November, December} name;

Typedef

Typedef is used to explicitly define new data type names by using the keyword typedef. It defines a name for an existing data type but doesn't create a new data type.

typedef data-type name;

Example

typedef unsigned int distance;  // typedef of int 

Vectors

Vectors are same as dynamic arrays. They will be resized on element inseertions & deletions.

Functions associated with the vector are:

Following functions return iterator begin() end() rbegin() rend() cbegin() cend() crbegin() crend()

#include <iostream>
#include <vector>
  
using namespace std;
  
int main()
{
    vector<int> v1;
  
    for (int i = 1; i <= 10; i++)
        v1.push_back(i);
  
    cout << "Output of begin and end: ";
    for (auto i = v1.begin(); i != v1.end(); ++i)
        cout << *i << " ";
  
    return 0;
}

Stacks

Stacks are a type of container adaptors with LIFO(Last In First Out) type of working, where a new element is added at one end (top) and an element is removed from that end only.

The functions associated with stack are: empty() – Returns whether the stack is empty – Time Complexity : O(1) size() – Returns the size of the stack – Time Complexity : O(1) top() – Returns a reference to the top most element of the stack – Time Complexity : O(1) push(g) – Adds the element ‘g’ at the top of the stack – Time Complexity : O(1) pop() – Deletes the top most element of the stack – Time Complexity : O(1)

#include <iostream>
#include <stack>
using namespace std;
int main() {
	stack<int> stack;
	stack.push(21);
	stack.push(22);
	stack.push(24);
	stack.push(25);
	
		stack.pop();
	stack.pop();

	while (!stack.empty()) {
		cout << ' ' << stack.top();
		stack.pop();
	}
}

Queue

Queues are a type of container adaptors that operate in a first in first out (FIFO) type of arrangement. Elements are inserted at the back (end) and are deleted from the front

queue::empty() Returns whether the queue is empty. queue::size() Returns the size of the queue. queue::swap() Exchange the contents of two queues but the queues must be of the same type, although sizes may differ. queue::emplace() Insert a new element into the queue container, the new element is added to the end of the queue. queue::front() Returns a reference to the first element of the queue. queue::back() Returns a reference to the last element of the queue. queue::push(g) Adds the element ‘g’ at the end of the queue. queue::pop() removes the element

#include <iostream>
#include <queue>
using namespace std;
int main() {
	queue<int> q;
	q.push(21);
	q.push(22);
	q.push(24);
	q.push(25);
	
		q.pop();
	q.pop();

	while (!q.empty()) {
		cout << ' ' << q.front();
		q.pop();
	}
}

Sort one-line

Sorting is one of the most basic functions applied to data. It means arranging the data in a particular fashion, which can be increasing or decreasing. There is a builtin function in C++ STL by the name of sort(). This function internally uses IntroSort. In more details it is implemented using hybrid of QuickSort, HeapSort and InsertionSort.

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

int main(){

int arr[] = {3,2,1};
int n = 3 ; // size of the array

sort(arr, arr+n); // sorting the array

vector<int> v;

v = {3,2,1};

sort(v.begin(), v.end()); // sorting in the vector

}

Header Files

Name Use
#include<stdio.h> It is used to perform input and output operations
#include<string.h> It is used to perform various string operations
#include<math.h> It is used to perform mathematical operations
#include<iomanip.h> It is used to access set() and setprecision()
#include<signal.h> It is used to perform signal handling functions like sign
#include<stdarg.h> It is used to perform standard argument functions
#include<errno.h> It is used to perform error handling operations like errno
#include<fstream.h> It is used to control the data to read from a file
#include<time.h> It is used to perform functions related to date() and time
#include<bits/stdc++.h> It is used to include all the standard library files