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.
cin >> x
: read value into the variable x from input streamcout << 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
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
./firstprogram
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 |
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
- 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
data-type array-name[size]; // one-dimensional Array
data-type array-name[size][size]; // two-dimensional Array
int a[5] = {1,2,3,4,5};
int a[2][3] = {
{1,2,3},
{4,5,6}
};
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 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 |
Operator type | Description |
---|---|
Arithmetic Operator | + , - , * , / , % |
comparision Operator | < , > , <= , >=, != , == |
Bitwise Operator | & , ^ , |
Logical Operator | && , || , ! |
Assignment Operator | = , += , -= , *= , /= , %=, <<=, >>=, &=, ^=, |= |
Ternary Operator | ? : |
sizeof operator | sizeof() |
if(conditional-expression)
{
//code
}
if(conditional-expression)
{
//code
} else {
//code
}
if(conditional-expression-1)
{
//code
} else if(conditional-expression-2) {
//code
} else if(conditional-expression-3) {
//code
}
....
else {
//code
}
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;
}
for(Initialization; Condition; Increment/decrement){
//code
}
while(condition){
//code
}
do{
//code
} while(condition);
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)
Pointer is a variable which holds the memory information(address) of another variable of same data type.
datatype *pointername;
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
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
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)
};
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;
enum month{January, February, March, April, May, June, July, August, September, October, November, December} name;
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;
typedef unsigned int distance; // typedef of int
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 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();
}
}
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();
}
}
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
}
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 |