0% found this document useful (0 votes)
18 views13 pages

Theory Based Question Answers of C

C++ is a general-purpose programming language that extends C by introducing object-oriented programming features like classes and inheritance. Key features of C++ include support for both procedural and object-oriented programming, a rich standard library, and mechanisms for exception handling and memory management. The document also explains various concepts such as tokens, data types, control statements, functions, and the differences between call by value and call by reference.

Uploaded by

sahilkamboj12312
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
18 views13 pages

Theory Based Question Answers of C

C++ is a general-purpose programming language that extends C by introducing object-oriented programming features like classes and inheritance. Key features of C++ include support for both procedural and object-oriented programming, a rich standard library, and mechanisms for exception handling and memory management. The document also explains various concepts such as tokens, data types, control statements, functions, and the differences between call by value and call by reference.

Uploaded by

sahilkamboj12312
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 13

Theory based question answers of c++ language

### 1. What is C++? How is it different from C?

**C++** is a general-purpose programming language that was


developed as an extension of the C programming language. It was
created by Bjarne Stroustrup in the early 1980s. C++ introduces object-
oriented programming (OOP) features, such as classes and objects,
while retaining the efficiency and flexibility of C.

**Key Differences Between C and C++:**

- **Paradigm**: C is a procedural programming language, while C++


supports both procedural and object-oriented programming paradigms.
- **OOP Features**: C++ introduces classes, objects, inheritance,
polymorphism, encapsulation, and abstraction, which are not present in
C.
- **Standard Library**: C++ has a richer standard library, including the
Standard Template Library (STL), which provides templates for common
data structures and algorithms.
- **Function Overloading**: C++ supports function overloading (multiple
functions with the same name but different parameters), while C does
not.
- **Namespaces**: C++ uses namespaces to avoid name collisions,
whereas C does not have this feature.
- **Exception Handling**: C++ provides built-in support for exception
handling using `try`, `catch`, and `throw`, which is absent in C.
- **Constructors and Destructors**: C++ allows the use of constructors
and destructors for object initialization and cleanup, which C lacks.
- **References**: C++ supports references (an alias for a variable),
while C only uses pointers.

---

### 2. What are the key features of C++?

The key features of C++ include:

1. **Object-Oriented Programming (OOP)**:


- Supports classes, objects, inheritance, polymorphism,
encapsulation, and abstraction.
- Enables modular and reusable code.

2. **Procedural Programming**:
- Retains the procedural programming style of C, allowing for
structured programming.

3. **Standard Template Library (STL)**:


- Provides pre-built templates for data structures (e.g., vectors, lists,
maps) and algorithms (e.g., sorting, searching).

4. **Function Overloading**:
- Allows multiple functions with the same name but different
parameters.

5. **Operator Overloading**:
- Enables defining custom behavior for operators (e.g., `+`, `-`, `*`)
for user-defined types.

6. **Exception Handling**:
- Provides mechanisms for handling runtime errors using `try`,
`catch`, and `throw`.

7. **Namespaces**:
- Helps avoid naming conflicts by grouping entities under a unique
scope.

8. **Constructors and Destructors**:


- Automates object initialization and cleanup.

9. **Templates**:
- Supports generic programming by allowing functions and classes to
operate with any data type.

10. **Memory Management**:


- Provides control over dynamic memory allocation and deallocation
using `new` and `delete`.

11. **Multi-threading**:
- Supports concurrent programming through libraries like
`<thread>`.

12. **Portability**:
- C++ code can be compiled and run on various platforms with
minimal changes.
---

### 3. What is the difference between procedural and object-oriented


programming?

| **Aspect** | **Procedural Programming** |


**Object-Oriented Programming (OOP)** |
|-----------------------------|---------------------------------------------------------|----------
---------------------------------------------|
| **Focus** | Focuses on procedures or functions.
| Focuses on objects and their interactions. |
| **Program Structure** | Programs are divided into functions.
| Programs are divided into classes and objects. |
| **Data and Behavior** | Data and functions are separate.
| Data and functions are encapsulated together in objects. |
| **Reusability** | Limited reusability through functions.
| High reusability through inheritance and polymorphism. |
| **Approach** | Top-down approach (programs are broken into
functions).| Bottom-up approach (programs are built using objects).|
| **Data Security** | Less secure, as data is globally accessible.
| More secure, as data is encapsulated and accessed via methods. |
| **Examples** | C, Pascal, FORTRAN. | C+
+, Java, Python. |
| **Key Concepts** | Functions, variables, and procedures.
| Classes, objects, inheritance, polymorphism, encapsulation, and
abstraction. |
| **Complexity Management** | Suitable for small to medium-sized
programs. | Suitable for large and complex programs. |

In summary, procedural programming is function-centric, while object-


oriented programming is object-centric, emphasizing modularity,
reusability, and data security. C++ supports both paradigms, making it
a versatile language.

### 1. What are tokens in C++? Explain with examples.

**Tokens** are the smallest individual units in a C++ program. They are
the building blocks of a program and are recognized by the compiler.
Tokens include:

- **Keywords** (e.g., `int`, `if`, `else`)


- **Identifiers** (e.g., variable names like `count`, `sum`)
- **Constants/Literals** (e.g., `10`, `3.14`, `'A'`)
- **Operators** (e.g., `+`, `-`, `*`, `/`)
- **Special Symbols** (e.g., `;`, `{}`, `()`)
**Example:**
```cpp
int main() {
int a = 10; // 'int', 'main', 'a', '10', ';' are tokens
return 0;
}
```

---

### 2. What are keywords, identifiers, constants, and literals in C++?

#### **Keywords**:
- Keywords are reserved words that have special meaning in C++.
- They cannot be used as identifiers (e.g., variable names).
- Examples: `int`, `if`, `else`, `while`, `return`, `class`, `public`, etc.

#### **Identifiers**:
- Identifiers are names given to variables, functions, classes, etc.
- Rules for identifiers:
- Must start with a letter or underscore (`_`).
- Can contain letters, digits, or underscores.
- Cannot be a keyword.
- Case-sensitive.
- Examples: `sum`, `myVariable`, `calculateArea`, `_count`.

#### **Constants/Literals**:
- Constants are fixed values that do not change during program
execution.
- Literals are the actual values assigned to variables or constants.
- Examples:
- Integer literal: `10`
- Floating-point literal: `3.14`
- Character literal: `'A'`
- String literal: `"Hello"`

---
### 3. Explain the different data types in C++.

C++ supports a variety of data types, which can be categorized as


follows:

#### **Primitive/Built-in Data Types**:


1. **Integer Types**:
- `int`: Stores whole numbers (e.g., `10`, `-5`).
- `short`: Smaller range than `int`.
- `long`: Larger range than `int`.
- `long long`: Even larger range.

2. **Floating-Point Types**:
- `float`: Single-precision floating-point numbers (e.g., `3.14f`).
- `double`: Double-precision floating-point numbers (e.g., `3.14`).
- `long double`: Extended precision floating-point numbers.

3. **Character Types**:
- `char`: Stores a single character (e.g., `'A'`).
- `wchar_t`: Wide character for larger character sets.

4. **Boolean Type**:
- `bool`: Stores `true` or `false`.

#### **Derived Data Types**:


1. **Arrays**:
- Collection of elements of the same type (e.g., `int arr[5];`).

2. **Pointers**:
- Stores memory addresses (e.g., `int *ptr;`).

3. **References**:
- Alias for a variable (e.g., `int &ref = a;`).

#### **User-Defined Data Types**:


1. **Structures (`struct`)**:
- Groups related data items of different types.

2. **Classes (`class`)**:
- Blueprint for objects, supporting OOP features.

3. **Unions (`union`)**:
- Similar to structures but shares memory for its members.

4. **Enumerations (`enum`)**:
- Defines a set of named integer constants.

---

### 4. What is type conversion? Explain implicit and explicit type


conversion.

#### **Type Conversion**:


- Type conversion is the process of converting a value from one data
type to another.

#### **Implicit Type Conversion**:


- Also called **automatic type conversion**.
- Performed by the compiler automatically when compatible types are
involved.
- Example:
```cpp
int a = 10;
double b = a; // 'a' is implicitly converted to double
```

#### **Explicit Type Conversion**:


- Also called **type casting**.
- Requires manual intervention using casting operators.
- Example:
```cpp
double x = 3.14;
int y = (int)x; // 'x' is explicitly cast to int
```

---

### 5. What is the difference between type casting and type


conversion?
| **Aspect** | **Type Conversion** | **Type
Casting** |
|------------------------|----------------------------------------------|--------------------------
-----------------|
| **Definition** | General term for converting one type to another. |
Specific form of type conversion, often explicit. |
| **Implicit/Explicit** | Can be implicit (automatic) or explicit. |
Always explicit (manual). |
| **Syntax** | Implicit: No syntax required. | Uses
casting operators like `(int)`, `static_cast<int>()`. |
| **Example** | `double b = 10;` (implicit). | `int y =
(int)3.14;` (explicit). |
| **Use Case** | Used when types are compatible. | Used
when types are incompatible or precision loss is expected. |

In summary, type conversion is a broader term that includes both


implicit and explicit changes, while type casting specifically refers to
explicit conversion.

### 1. What are control statements in C++? Explain types of loops.

**Control Statements** in C++ are used to control the flow of execution


in a program based on certain conditions or loops. They include:

1. **Conditional Statements**:
- `if`, `else if`, `else`: Execute code based on a condition.
- `switch`: Execute code based on the value of a variable.

2. **Looping Statements**:
- **`for` loop**: Repeats a block of code a specific number of times.
```cpp
for (int i = 0; i < 5; i++) {
cout << i << endl;
}
```
- **`while` loop**: Repeats a block of code as long as a condition is
true.
```cpp
int i = 0;
while (i < 5) {
cout << i << endl;
i++;
}
```
- **`do-while` loop**: Executes the block of code at least once, then
repeats as long as the condition is true.
```cpp
int i = 0;
do {
cout << i << endl;
i++;
} while (i < 5);
```

3. **Jump Statements**:
- `break`: Exits a loop or switch statement.
- `continue`: Skips the current iteration of a loop.
- `return`: Exits a function and optionally returns a value.
- `goto`: Jumps to a labeled statement (rarely used).

---

### 2. What is the difference between "while" and "do-while" loops?

| **Aspect** | **`while` Loop** | **`do-while`


Loop** |
|------------------------|-----------------------------------------------|-------------------------
-------------------|
| **Condition Check** | Condition is checked **before** the loop body
executes. | Condition is checked **after** the loop body executes. |
| **Execution** | The loop body may not execute at all if the
condition is false initially. | The loop body executes **at least once**,
even if the condition is false initially. |
| **Syntax** | ```cpp while (condition) { ... } ``` | ```cpp do
{ ... } while (condition); ``` |
| **Use Case** | Used when the loop body should execute only if
the condition is true. | Used when the loop body must execute at least
once. |

**Example**:
```cpp
int i = 5;
while (i < 5) { // This loop will not execute
cout << i << endl;
i++;
}

do { // This loop will execute once


cout << i << endl;
i++;
} while (i < 5);
```

---

### 3. What are functions in C++? Explain types of functions.

**Functions** in C++ are reusable blocks of code that perform a specific


task. They help in modularizing code and improving readability.

#### **Types of Functions**:


1. **Predefined (Library) Functions**:
- Functions provided by C++ standard libraries (e.g., `cout`, `sqrt()`).

2. **User-Defined Functions**:
- Functions defined by the programmer.
- Example:
```cpp
int add(int a, int b) {
return a + b;
}
```

3. **Parameterized Functions**:
- Functions that accept parameters (arguments).

4. **Non-Parameterized Functions**:
- Functions that do not accept any parameters.

5. **Return Type Functions**:


- Functions that return a value using the `return` statement.
6. **Void Functions**:
- Functions that do not return any value.

---

### 4. What is function overloading? Explain with an example.

**Function Overloading** is a feature in C++ that allows multiple


functions to have the same name but different parameters (number or
type of parameters).

**Example**:
```cpp
#include <iostream>
using namespace std;

// Function to add two integers


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

// Function to add three integers


int add(int a, int b, int c) {
return a + b + c;
}

// Function to add two doubles


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

int main() {
cout << add(2, 3) << endl; // Calls first function
cout << add(2, 3, 4) << endl; // Calls second function
cout << add(2.5, 3.5) << endl; // Calls third function
return 0;
}
```
**Output**:
```
5
9
6.0
```

---

### 5. What is the difference between call by value and call by


reference?

| **Aspect** | **Call by Value** | **Call by


Reference** |
|------------------------|----------------------------------------------|--------------------------
------------------|
| **Definition** | A copy of the actual value is passed to the
function. | The address of the actual value is passed to the function. |
| **Effect on Original Value** | Changes made to the parameter do not
affect the original value. | Changes made to the parameter affect the
original value. |
| **Syntax** | ```cpp void func(int a) { ... } ``` | ```cpp void
func(int &a) { ... } ``` |
| **Use Case** | Used when the original value should not be
modified. | Used when the original value needs to be modified. |

**Example**:
```cpp
#include <iostream>
using namespace std;

// Call by value
void incrementByValue(int a) {
a++;
}

// Call by reference
void incrementByReference(int &a) {
a++;
}
int main() {
int x = 5;
incrementByValue(x); // x remains 5
cout << x << endl;

incrementByReference(x); // x becomes 6
cout << x << endl;
return 0;
}
```

**Output**:
```
5
6
```

---

### 6. What are inline functions? What are their advantages?

**Inline Functions**:
- Inline functions are functions where the compiler replaces the function
call with the actual code of the function to reduce the overhead of
function calls.
- Defined using the `inline` keyword.

**Example**:
```cpp
#include <iostream>
using namespace std;

inline int square(int x) {


return x * x;
}

int main() {
cout << square(5) << endl; // Compiler replaces square(5) with 5 * 5
return 0;
}
```

**Advantages**:
1. **Reduced Overhead**:
- Eliminates the overhead of function calls (saving and restoring
registers, stack operations, etc.).
2. **Faster Execution**:
- Suitable for small, frequently called functions.
3. **Improved Performance**:
- Useful in performance-critical applications.

**Disadvantages**:
1. **Increased Binary Size**:
- The code is duplicated at each call site, increasing the size of the
executable.
2. **Not Suitable for Large Functions**:
- Inlining large functions can lead to code bloat.

**Note**: The `inline` keyword is a request to the compiler, and the


compiler may ignore it for large or complex functions.

You might also like