0% found this document useful (0 votes)
17 views

C++ All Codes

The document covers 12 topics on C++ concepts like variables, data structures, classes, inheritance, templates, exceptions, and file handling. Code examples are provided for each topic to demonstrate the core concepts.

Uploaded by

Lakshya Sharma
Copyright
© © All Rights Reserved
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
17 views

C++ All Codes

The document covers 12 topics on C++ concepts like variables, data structures, classes, inheritance, templates, exceptions, and file handling. Code examples are provided for each topic to demonstrate the core concepts.

Uploaded by

Lakshya Sharma
Copyright
© © All Rights Reserved
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 6

### 1.

Basics of C++ Library, Variables, Data Input-Output


```cpp
#include <iostream>
using namespace std;

int main() {
// Basics of C++ library, variables, data input-output
int num;
cout << "Enter a number: ";
cin >> num;
cout << "You entered: " << num << endl;

return 0;
}
```

### 2. C++ Program using Structures


```cpp
#include <iostream>
using namespace std;

struct Point {
int x, y;
};

int main() {
// C++ program using structures
Point p;
p.x = 5;
p.y = 10;
cout << "Coordinates: (" << p.x << ", " << p.y << ")" << endl;

return 0;
}
```

### 3. Class and Object Concepts, Function Overloading


```cpp
#include <iostream>
using namespace std;

class Calculator {
public:
int add(int a, int b) {
return a + b;
}

double add(double a, double b) {


return a + b;
}
};

int main() {
// Class and object concepts, function overloading
Calculator calc;
cout << "Sum (int): " << calc.add(3, 5) << endl;
cout << "Sum (double): " << calc.add(3.5, 2.7) << endl;
return 0;
}
```

### 4. Dynamic Memory Allocation and Array of Objects


```cpp
#include <iostream>
using namespace std;

class DynamicArray {
public:
int* arr;
int size;

DynamicArray(int n) {
size = n;
arr = new int[size];
}

~DynamicArray() {
delete[] arr;
}
};

int main() {
// Dynamic memory allocation and array of objects
DynamicArray arrObj(5);

// Accessing and manipulating arrObj.arr goes here

return 0;
}
```

### 5. Different Types of Constructors and Destructor


```cpp
#include <iostream>
using namespace std;

class MyClass {
public:
MyClass() {
cout << "Default Constructor" << endl;
}

MyClass(int value) {
cout << "Parameterized Constructor: " << value << endl;
}

~MyClass() {
cout << "Destructor" << endl;
}
};

int main() {
// Different types of constructors and destructor
MyClass obj1;
MyClass obj2(42);
return 0;
}
```

### 6. Friend Function, `this` Pointer


```cpp
#include <iostream>
using namespace std;

class MyClass {
private:
int privateData;

public:
MyClass(int data) : privateData(data) {}

friend void accessPrivateData(MyClass obj);


};

void accessPrivateData(MyClass obj) {


cout << "Private Data: " << obj.privateData << endl;
}

int main() {
// Friend function and usage of this pointer
MyClass obj(15);
accessPrivateData(obj);

return 0;
}
```

### 7. Constant Data Member, Member Function, Static Data Member, Static Member
Function
```cpp
#include <iostream>
using namespace std;

class Example {
public:
static int staticData;
int normalData;

void displayNormalData() const {


// constant member function
// normalData = 10; // Error: cannot modify non-static member within const
member function
cout << "Normal Data: " << normalData << endl;
}

static void displayStaticData() {


// static member function
cout << "Static Data: " << staticData << endl;
}
};

int Example::staticData = 5; // Initialization of static data member

int main() {
// Usage of constant data member, constant member function, static data member,
and static member function
Example obj1, obj2;
obj1.normalData = 7;
obj1.displayNormalData();
obj2.displayNormalData(); // Accessing constant member function for obj2
Example::displayStaticData();

return 0;
}
```

### 8. Different Types of Inheritance, Function Overriding, Virtual Function


```cpp
#include <iostream>
using namespace std;

class Shape {
public:
virtual void draw() {
cout << "Drawing a shape." << endl;
}
};

class Circle : public Shape {


public:
void draw() override {
cout << "Drawing a circle." << endl;
}
};

int main() {
// Different types of inheritance, function overriding, and virtual function
Circle circle;
Shape* shapePtr = &circle;
shapePtr->draw(); // Calls the overridden function

return 0;
}
```

### 9. Operator Overloading


```cpp
#include <iostream>
using namespace std;

class Complex {
public:
double real, imag;

Complex operator+(const Complex& other) {


Complex result;
result.real = real + other.real;
result.imag = imag + other.imag;
return result;
}
};

int main() {
// Operator overloading
Complex c1, c2, sum;
c1.real = 2.5;
c1.imag = 3.0;
c2.real = 1.5;
c2.imag = 2.5;

sum = c1 + c2;
cout << "Sum: " << sum.real << " + " << sum.imag << "i" << endl;

return 0;
}
```

### 10. Function Template, Class Template


```cpp
#include <iostream>
using namespace std;

template <typename T>


T add(T a, T b) {
return a + b;
}

template <class T>


class Pair {
public:
T first, second;

Pair(T f, T s) : first(f), second(s) {}


};

int main() {
// Function template and class template
int intSum = add(3, 5);
double doubleSum = add(3.5, 2.7);

Pair<int> intPair(1, 2);


Pair<double> doublePair(3.5, 2.7);

return 0;
}
```

### 11. Exception Handling


```cpp
#include <iostream>
using namespace std;

int main() {
// Exception handling
try {
int numerator = 10;
int denominator = 0;
if (denominator == 0) {
throw runtime_error("Division by zero");
}
int result = numerator / denominator;
cout << "Result: " << result << endl;
} catch (const exception& e) {
cerr << "Error: " << e.what() << endl;
}

return 0;
}
```

### 12. File Handling


```cpp
#include <iostream>
#include <fstream>
using namespace std;

int main() {
// File handling
ofstream outFile("example.txt");
if (outFile.is_open()) {
outFile << "Hello, File Handling!";
outFile.close();
} else {
cerr << "Unable to open file.";
}

ifstream inFile("example.txt");
if (inFile.is_open()) {
string line;
while (getline(inFile, line)) {
cout << line << endl;
}
inFile.close();
} else {
cerr << "Unable to open file.";
}

return 0;
}
```

You might also like