C++ Basics & Program Structure Interview Questions

C++ is a structured and object-oriented language used in systems programming, game development, competitive coding.

1. How does C++ enable both high-level and low-level programming, and what features make it suitable for systems-level development?

C++ is called a middle-level language because it combines the features of both high-level and low-level programming.

• High-level features: It supports abstraction, object-oriented programming, templates, and the standard library, which make writing complex applications easier and closer to human thinking.
• Low-level features: It allows direct memory management using pointers, inline assembly, and hardware-level manipulation, which makes it suitable for systems programming like operating systems, compilers, and device drivers.

Reasons why C++ is suitable for systems-level development:

1. Direct Memory Access: Through pointers and pointer arithmetic.
2. Manual Resource Management: Developers can control memory allocation/deallocation using new and delete.
3. Performance: Minimal runtime overhead compared to other higher-level languages.
4. Object-Oriented Design: Helps in organizing large system codebases (e.g., OS kernels, databases).

#include <iostream>
using namespace std;

int main() {
    int x = 10;          // high-level: simple variable
    int* p = &x;         // low-level: direct memory access with pointer

    *p = 20;             // modifying value through pointer
    cout << "x = " << x << endl;

    return 0;
}

• High-level: int x = 10; shows simple variable handling.
• Low-level: int* p = &x; and *p = 20; show direct memory manipulation.
• It clearly demonstrates how C++ can act at both levels in just a few lines.

2. Whats is 'namespace std'?

'std' stands for Standard. It is a namespace in C++. Namespace is a feature that provides a way to group related identifiers such as variables, functions, and classes under a single name. The line "using namespace std" informs the compiler to add everything under the std namespace and inculcate them in the global namespace. This all inculcation of global namespace benefits us to use "cout" and "cin" without using "std::_operator_".

#include <iostream>
using namespace std;

int main() {
    cout << "Hello using std namespace!" << endl;
    return 0;
}

3. What are references in C++?

In C++, references is a way to create an alias for another variable.

• A reference acts as a synonym for a variable, allowing you to access the variable directly without any additional syntax.
• They must be initialized when created and cannot be changed to refer to another variable afterward.
• This feature makes it easier to manipulate variables in functions while avoiding the overhead of copying large objects. A reference variable is preceded with a '&' symbol.

Syntax:

int GFG = 10;
// reference variable
int& ref = GFG;

#include <iostream>
using namespace std;

int main() {
    int a = 10;
    int &ref = a;

    ref = 20;
    cout << "a = " << a << ", ref = " << ref << endl;
    return 0;
}

4. Define the Block scope variable. 

A block scope variable is also known as a local scope variable. A variable that is defined inside a function (like main) or inside a block (anything enclosed with curly braces like loops and if else) is a local variable. A block-scoped variable will not be available outside the block even if the block is inside a function.

#include <iostream>
using namespace std;

int main() {
    int a = 10; // local to main

    if (a > 5) {
        int b = 20;  // block scope inside if-block
        cout << "Inside if-block: a = " << a << ", b = " << b << endl;
    }
    for (int i = 0; i < 3; i++) {
        int temp = i * 10;  // block scope inside for-loop
        cout << "temp = " << temp << endl;
    }

    return 0;
}

5. What does the "auto" keyword do?

The auto keyword is a type inference specifier introduced in C++11, which tells the compiler to automatically deduce the type of a variable from its initializer expression.

Primary Function of auto:

• Simplifies declarations (especially for iterators, lambdas, template types).
• Enhances code readability and maintainability.
• Reduces redundancy and typing errors.
• Promotes use of generic programming.

Use Case: With Iterators use this

#include <bits/stdc++.h>
using namespace std;

int main() {

    vector<int> v = {1, 2, 3, 4};
    for (auto it = v.begin(); it != v.end(); ++it)
        cout << *it << " ";

    return 0;
}

Instead of this:

std::vector<int>::iterator it = v.begin();

6. What do you mean by Pass by Value and Pass by Reference?

In this programming language to call a function we have 2 methods: Pass by Value and Pass by Reference

Pass by Value:

#include <iostream>
using namespace std;

void modify(int x) {
    x = x + 10;
}

int main() {
    int a = 5;
    modify(a);
    cout << "Value after call by value: " << a << endl;
    return 0;
}

Pass by Reference:

#include <iostream>
using namespace std;

void modify(int &x) {
    x = x + 10;
}

int main() {
    int a = 5;
    modify(a);
    cout << "Value after call by reference: " << a << endl;
    return 0;
}

7. Define token in C++

A token is the smallest individual element of a program that is understood by a compiler. A token comprises the following:

1. Keywords: That contain a special meaning to the compiler
2. Identifiers: That hold a unique value/identity 
3. Constants: That never change their value throughout the program 
4. Strings: That contains the homogenous sequence of data 
5. Special Symbols: They have some special meaning and cannot be used for another purpose; eg: [] () {}, ; * = # 
6. Operators: Who perform operations on the operand

#include <iostream>
using namespace std; // Keyword

int main() {
    int age = 25;       // int (keyword), age (identifier), 25 (constant)
    cout << "Age: " << age << endl; // "Age:" (string), << (operator)
    return 0;           // return (keyword), 0 (constant)
}

8. What is the difference between C and C++?

The following table lists the major differences between C and C++:

C Code (No OOP):

#include <stdio.h>

void greet() {
    printf("Hello from C-style function!\n");
}

int main() {
    greet();
    return 0;
}

C++ Code with OOP:

#include <iostream>
using namespace std;

class Greet {
public:
    void sayHello() {
        cout << "Hello from C++ class!" << endl;
    }
};

int main() {
    Greet g;
    g.sayHello();
    return 0;
}

9. What happens if you use cout without using namespace std or std::cout? Why is namespace resolution important in large C++ projects?

In C++, cout belongs to the std namespace. If you forget to use using namespace std; or std::cout, you'll get a compiler error. In large projects, polluting the global namespace can lead to naming collisions

#include <iostream>
// using namespace std; // not used intentionally

int main() {
    std::cout << "Using std::cout directly avoids namespace pollution\n";
    return 0;
}

10. What is the difference between const and #define?

• const: A typed constant with scope rules, checked by the compiler.
• #define: A preprocessor macro replaced before compilation, no type checking.

• const int x = 10; // Type safe
• #define y 10 // No type checking

11. What are default arguments?

Default arguments are values that are used when a function is called without some parameters.

#include <iostream>
using namespace std;

void greet(string name = "Guest") {
    cout << "Hello " << name;
}

int main() {
    greet();
    return 0;
}

12. What are type modifiers in C++?

Modifiers like signed, unsigned, long, short change the size or sign of basic data types.

Example:

unsigned int a = 5;
long double b = 5.66;

#include <iostream>
using namespace std;

int main() {
    unsigned int u = 10;
    signed int s = -20;
    short sh = 30000;
    long lg = 100000L;
    long long ll = 9223372036854775807LL;

    cout << "unsigned int: " << u << endl;
    cout << "signed int: " << s << endl;
    cout << "short: " << sh << endl;
    cout << "long: " << lg << endl;
    cout << "long long: " << ll << endl;

    return 0;
}

13. How does type deduction using auto and decltype in C++ enhance type safety and flexibility? Show how these modern features relate to built-in and user-defined data types.

Explanation: Instead of manually specifying data types, C++ allows the compiler to deduce the type using:

• auto: Deduces the type from initializer.
• decltype: Infers type from an expression.

These features:

• Reduce boilerplate.
• Improve maintainability.
• Prevent type mismatches.

Code Example:

#include <iostream>
using namespace std;

int getNumber() { return 42; }

int main() {
    auto x = 10.5;          // deduced as double
    decltype(getNumber()) y = 5; // deduced as int (from return type)

    cout << "x: " << x << ", y: " << y << endl;
    return 0;
}

14. What is a reference in C++ and how is it different from a pointer?

• A reference is an alias for another variable. Once initialized, it always refers to the same variable.
• A pointer stores the address of a variable and can be changed to point somewhere else.
• References do not need dereferencing (*) to access the value; they behave just like the original variable.

#include <iostream>
using namespace std;

int main() {
    int a = 10;

    int& ref = a;   // reference to a
    int* ptr = &a;  // pointer to a

    ref = 20;       // changes a
    *ptr = 30;      // also changes a

    cout << a;      // prints 30
}

15. Can a reference be reseated to another variable after initialization? What happens if you try to return a reference to a local variable?

• References cannot be reseated.
• Returning a reference to a local variable causes undefined behavior — you're returning a variable that no longer exists after function ends.

Code:

#include <iostream>
using namespace std;

int& getLocal() {
    int a = 10;
    return a; // Returning reference to a local variable (UB)
}

int main() {
    int &ref = getLocal();
    cout << "Undefined behavior: " << ref << endl;
    return 0;
}

16. Discuss the difference between prefix and postfix?

Following are the major difference between prefix and postfix:

17.  Define namespace in C++.

Namespaces enable us to organize named items that would otherwise have global scope into smaller scopes, allowing us to give them namespace scope. This permits program parts to be organized into distinct logical scopes with names. The namespace provides a place to define or declare identifiers such as variables, methods, and classes. 

Or we could say that A namespace is a declarative zone that gives the identifiers (names of types, functions, variables, and so on) within it a scope. Namespaces are used to arrange code into logical categories and to avoid name clashes, which might happen when you have many libraries in your code base.

#include <iostream>
using namespace std;

// Define a namespace called "MathOps"
namespace MathOps {
    int add(int a, int b) {
        return a + b;
    }

    int multiply(int a, int b) {
        return a * b;
    }
}

int main() {
    int x = 5, y = 3;

    // Access functions using namespace scope resolution
    cout << "Addition: " << MathOps::add(x, y) << endl;
    cout << "Multiplication: " << MathOps::multiply(x, y) << endl;

    return 0;
}

18. When is void() return type used?

The void keyword, when used as a function return type, indicates that the function does not return a value. You can use return; in such functions, but you cannot return an actual value. When used as a parameter list (e.g., void f(void) in C-style), it means the function takes no parameters.

#include <iostream>
using namespace std;

void greet() {
    cout << "Hello from a void function!\n";
    return;  // valid, though it returns nothing
}

int main() {
    greet();
    return 0;
}

19. What is the difference between a reference and a pointer?

• Reference is an alias for a variable. It cannot be NULL and must be initialized.
• Pointer is a variable storing address. It can be reassigned and can be NULL.

#include <iostream>
using namespace std;

int main() {
    int a = 10;

    int& ref = a;    // reference
    int* ptr = &a;   // pointer

    cout << "ref: " << ref << endl;
    cout << "ptr: " << *ptr << endl;

    *ptr = 20;
    cout << "After changing via pointer, a = " << a << endl;

    ref = 30;
    cout << "After changing via reference, a = " << a << endl;

    return 0;
}

20. In the line "int* a, b;", how many pointers are declared?

Many assume both a and b are pointers, but only a is a pointer — b is just an int.

Code Example:

#include <iostream>
using namespace std;

int main() {
    int* a, b; // a is a pointer, b is just an int
    int x = 5;
    a = &x;
    cout << "Pointer a: " << *a << ", Integer b: " << b << endl;
    return 0;
}

21. Define storage class in C++ and name some

Storage class is used to defines the scope (visibility), lifetime, and linkage of variables or functions. These features usually help in tracing the existence of a variable during the runtime of a program.

Syntax:

storage_class var_data_type var_name;

Some types of storage classes:

22. What is a mutable storage class specifier? How can they be used?

The mutable keyword is a storage class specifier used only with non-static data members of a class. It allows a member of a const object to be modified. Normally, if an object is declared const, you cannot modify any of its members, but mutable makes an exception.

Key Points:

• Used only with non-static, non-const, and non-reference data members.
• Allows modification even inside: A const object & A const member function
• Useful in caching, lazy evaluation, logging, etc., where some internal state can change without affecting observable behavior.

Why is mutable Needed: When a member function is marked as const like this

void show() const;

It cannot modify any data members of the object, because this becomes a const pointer (i.e., const ClassName* this). But sometimes, you want to modify an internal variable (e.g., access counter, log flag) that is not part of the logical state of the object. That’s where mutable helps.

Example:

#include <iostream>
using namespace std;

class Logger {
private:
    mutable int accessCount; // can change even in const functions
    string data;
public:
    Logger(string d) : data(d), accessCount(0) {}

    void showData() const {
        accessCount++;  // allowed because accessCount is mutable
        cout << "Data: " << data << ", Accessed: " << accessCount << " times\n";
    }
};

int main() {
    const Logger log("Secret Info");

    log.showData();  // Allowed even though log is const
    log.showData();  // Internal counter keeps updating
}

Even though log is declared as const, accessCount is being updated, because it is declared mutable.