Section 5 : C++ Pointers + new + Arrays +Static+reference+initilization list+Namespaces

Question 1

Q: What does int* pointVar = new int; do?

Answer 1

It creates a pointer to an integer and dynamically allocates memory for one int.
pointVar now holds the address of that memory.

Question 2

Q: How do you assign a value to dynamically allocated memory?

Answer 2

Use the dereference operator:
*pointVar = 45;
This puts the value 45 into the memory that pointVar points to.

Question 3

How do you allocate an array dynamically in C++?

Answer 3

float* arr = new float[3];
This allocates space for 3 float values and stores the address of the first element in arr.

Question 4

Why is *arr = [12.3, 12.1, 11.0]; incorrect in C++?

Answer 4

Because you can’t assign an entire array like that.
Instead, assign one element at a time:

arr[0] = 12.3; arr[1] = 12.1; arr[2] = 11.0;

Question 5

What does *arr give you?

Answer 5

It gives you the value at index 0 of the array.
*arr is the same as arr[0].

Question 6

What’s the difference between delete and delete[]?

Answer 6

Use delete to free memory from new int;

Use delete[] to free memory from new float[3];
(because arrays need special cleanup)

Question 7

What happens if you forget to use delete?

Answer 7

You get a memory leak — the memory stays allocated and unusable until the program ends. This can slow down or crash big programs.

Question 8

Why do you need a pointer when using new?

Answer 8

Because new gives you the memory address — a pointer is the only way to store and use that address in your program.

Question 9

What does the new operator do in C++?

Answer 9

It dynamically allocates memory at runtime and returns the address of the memory block.

Question 10

What does the this pointer become inside a const member function in C++?

Answer 10

Inside a const function, this becomes a const ClassName* (e.g., const Point* this).
This means the object is read-only in that function — you cannot modify its member variables.

Question 11

What is a static variable in a class?

Answer 11

A variable shared by all instances of the class.
Only one copy exists, and it belongs to the class itself.
class Counter {
public:
static int count; // shared across all objects
};
int Counter::count = 0;

Question 12

Where do you define and initialize a static variable?

Answer 12

Outside the class using the scope resolution operator ::.
int Counter::count = 0;

Question 13

What is a static function in a class?

Answer 13

A function that belongs to the class and can be called without an object. It can access only static members.

class Counter {
public:
static void reset() {
count = 0;
}
};

Question 14

Can a static function access non-static variables?

Answer 14

No — it does not have a this pointer, so it cannot access non-static members.

class Test {
int x;
public:
static void printX() {
cout &laquo_space;x; // ❌ Error: x is non-static
}
};

Question 15

How do you call a static function?

Answer 15

With the class name: ClassName::function() — no object needed.

Counter::reset(); // ✅ called directly

Question 16

Why are static variables and functions useful?

Answer 16

They allow shared data and class-level actions, like counting objects or providing utility functions.

class Counter {
static int count;
public:
Counter() { count++; }
static int getCount() { return count; }
};

Question 17

Where is a non-static member variable stored?

Answer 17

Inside each individual object.
Each object has its own copy in a different memory address.

Example:
Car a, b;
a.speed = 100;
b.speed = 200;

a.speed and b.speed stored at different addresses (e.g., 0x101, 0x201)

Question 18

Where is a static member variable stored?

Answer 18

In a separate memory area (not inside objects).
All objects share the same memory location.
Car::totalCars = 2;
Only one copy in memory (e.g., 0x301) used by all Car objects

Question 19

If you create 3 objects, how many copies of a static variable exist?

Answer 19

Only one — shared across all objects.

Question 20

If you create 3 objects, how many copies of a non-static variable exist?

Answer 20

Three — each object has its own separate copy.

Question 21

Can you access the address of a static variable? Does it change?

Answer 21

✅ Yes, you can — using &ClassName::var or inside a function.
❗ Its address stays the same, no matter how many objects you create.

Question 22

Can a static member function access non-static members?

Answer 22

❌ No. Static functions do not have a this pointer and cannot access object-specific data.

Question 23

What happens if two objects write to the same static variable?

Answer 23

The last write wins — they are writing to the same memory location.
Car a, b;
a.totalCars = 3;
b.totalCars = 5;
// Now Car::totalCars == 5

Question 24

What does the mutable keyword do in C++?

Answer 24

mutable allows a class member variable to be modified even inside a const function.

class Point {
int x;
mutable int accessCount;
public:
int getX() const {
accessCount++; // ✅ allowed because it’s mutable
return x;
}
};

Use mutable for:

Logging

Access counters

Lazy computation / caching

Even in const methods, mutable members can change.

“mutable = my exception to the const rule”

Question 25

Can you assign a value to a reference member (int& y) inside the constructor body?

Answer 25

❌ No. Reference members must be bound during object creation using an initialization list. class MyClass { int& y; public: MyClass(int& b) : y(b) {} // ✅ bind y to b here }; Reference = needs a target immediately. Use the init list to bind it at birth — no second chance! class MyClass { int& y; public: MyClass(int& b) { y = b; // ❌ Error: reference must be initialized, not assigned } };

Question 26

Why and when do we use a constructor initialization list in C++?

Answer 26

To initialize members before the constructor body runs — especially const and reference members, which must be initialized this way. class MyThing { const int x; int& y; int z; public: MyThing(int a, int& b) : x(a), // ✅ const initialized y(b), // ✅ reference bound z(10) // ✅ optional but cleaner {} };

Question 27

Does the default copy constructor in C++ do a shallow copy or a deep copy?

Answer 27

✅ By default, the copy constructor performs a shallow copy. It copies each member bit-by-bit, including pointer addresses — not the actual data. ⚠️ Problem: If your class uses dynamic memory (with new), a shallow copy leads to: ❌ Shared pointers ❌ Double deletes ❌ Unexpected side effects To make a deep copy, you must write your own copy constructor: Box(const Box& other) { data = new int(*other.data); // deep copy } Now a and b don’t share memory.

Question 28

What does static do inside a function?

Answer 28

It makes the variable retain its value between function calls. It is initialized only once. void counter() { static int count = 0; cout << count++; }

Question 29

What is a static class member variable?

Answer 29

It is a variable that is shared by all objects of a class. Only one copy exists for the entire class. class A { public: static int sharedCount; }; int A::sharedCount = 0;

Question 30

Why would you use a static variable in a class?

Answer 30

To store information that is common to all objects (like a counter, ID tracker, or shared setting).

Question 31

What does a static function do?

Answer 31

It belongs to the class, not to any object, and can only access static variables. class A { static int count; public: static int getCount(); };

Question 32

Can a static method access regular (non-static) members?

Answer 32

No — because it has no this pointer. It only sees static stuff.

Question 33

Why do we use getters/setters for static members?

Answer 33

To control access to private static variables safely — instead of exposing them publicly. class Config { static int version; public: static int getVersion(); static void setVersion(int v); };

Question 34

What is the purpose of a namespace in C++?

Answer 34

A namespace is a container that groups identifiers (variables, functions, classes) to avoid naming conflicts.

Question 35

How do you define and use elements from a namespace?

Answer 35

namespace Math { int add(int a, int b) { return a + b; } } int result = Math::add(2, 3); // using the scope resolution operator ::

Question 36

What does the :: (scope resolution operator) do?

Answer 36

It lets you access a name (function/variable/class) inside a namespace or class. std::cout << "Hello";

Question 37

What does using namespace std; mean?

Answer 37

It tells the compiler to look in the std namespace by default, so you can write cout instead of std::cout. ⚠️ May cause name conflicts in large projects.

Question 38

Why do we use namespaces in real-world projects?

Answer 38

To keep code organized and avoid clashes when: Using multiple libraries Writing large programs Different parts use the same function/variable names