Section A — 1 Mark Questions
1. What is a static data member? [1 Mark]
Answer: A static data member is a class variable that is shared by all objects of that class.
2. How many copies of a static data member exist for a class? [1 Mark]
Answer: Only one copy exists, regardless of the number of objects created.
3. What is the default value of a static data member of type integer? [1 Mark]
Answer: The default value is zero.
4. Where are static data members defined? [1 Mark]
Answer: They are defined outside the class scope using the scope resolution operator.
5. Can a static member function access non-static data members? [1 Mark]
Answer: No, they cannot directly access non-static data members.
6. How can you call a static member function? [1 Mark]
Answer: By using the class name followed by the scope resolution operator.
7. Define function overloading. [1 Mark]
Answer: Function overloading is the ability to create multiple functions with the same name but different parameter lists.
8. What is the primary requirement for function overloading? [1 Mark]
Answer: The functions must have different parameter signatures (type or number of arguments).
9. Can function overloading occur based on return type alone? [1 Mark]
Answer: No, function overloading cannot be achieved by changing the return type only.
10. Is a static member function associated with a specific object? [1 Mark]
Answer: No, it is associated with the class itself rather than any specific object.
11. Which keyword is used to declare a static member? [1 Mark]
Answer: The static keyword.
12. Does a static member function have a 'this' pointer? [1 Mark]
Answer: No, static member functions do not have a 'this' pointer.
13. If a class has a static member, when is memory allocated for it? [1 Mark]
Answer: Memory is allocated when the program starts.
14. Can a static function be private? [1 Mark]
Answer: Yes, a static function can be declared as private.
15. What determines if a function is overloaded or re-defined? [1 Mark]
Answer: The parameter signature determines function overloading.
16. Can you overload a main function in C++? [1 Mark]
Answer: No, the main function cannot be overloaded.
17. What is the purpose of static members? [1 Mark]
Answer: To share data or common functionality across all instances of a class.
18. Does the static member exist even if no objects of the class are created? [1 Mark]
Answer: Yes, it exists independently of class objects.
19. What error occurs if you try to access a non-static member inside a static function? [1 Mark]
Answer: A compilation error occurs.
20. Does overloading occur at compile-time or runtime? [1 Mark]
Answer: Function overloading is a compile-time concept.
Section B — 2/3 Mark Questions
1. Explain the concept of shared memory in static data members. [2 Marks]
Answer: Static data members do not occupy space in individual objects. Instead, a single copy is stored in the data segment of memory, which is shared across all objects of that class.
2. Why can static member functions only access static data? [2 Marks]
Answer: Because static functions are not tied to any specific instance (object) of a class, they lack the 'this' pointer required to identify which object's non-static data members to access.
3. Write the syntax to declare and define a static member variable. [3 Marks]
Answer: 1. Declaration inside class: static int count;. 2. Definition outside class: int ClassName::count = 0;. 3. The definition is required to allocate memory.
4. Differentiate between static member variables and regular instance variables. [3 Marks]
Answer: Instance variables belong to specific objects and have individual values. Static variables belong to the class, have one value for all objects, and are initialized outside the class.
5. What are the rules for function overloading regarding parameters? [2 Marks]
Answer: Functions can be overloaded if they differ in the number of parameters or the data types of the parameters passed to them.
6. Explain the role of the scope resolution operator with static members. [2 Marks]
Answer: The scope resolution operator (::) is used to define static members outside the class and to access static members without creating an object instance.
7. Can static functions be overloaded? Explain. [2 Marks]
Answer: Yes, static member functions can be overloaded just like regular member functions, provided their parameter lists are different.
8. Why is function overloading considered a type of compile-time polymorphism? [3 Marks]
Answer: The compiler resolves which version of the overloaded function to call during the compilation process by matching the arguments provided in the function call with the available function signatures.
9. Give a brief example of why we might use a static data member. [3 Marks]
Answer: To keep track of the total number of objects created. By incrementing a static 'counter' variable in the constructor, we can maintain a global count across all instances without external global variables.
10. What happens if you fail to define a static data member outside the class? [2 Marks]
Answer: The program will compile but fail at the linking stage with an 'undefined reference' error, because the compiler needs a specific location in memory allocated for the static variable.
Section C — 5 Mark Questions
1. Elaborate on the role and characteristics of static data members in C++. [5 Marks]
Answer:
Concept
A static data member is a class-level variable that is shared by all objects. It is often referred to as a class variable rather than an instance variable.
Key Characteristics
- Storage: It is stored in a single memory location, separate from individual object data.
- Initialization: It must be defined and initialized outside the class using the scope resolution operator to allocate storage.
- Sharing: Any modification to a static member made by one object is reflected in all other objects of the same class.
- Lifetime: The variable exists for the entire duration of the program execution.
Usage
It is best used when information needs to be shared among all instances, such as maintaining a global count of objects created, or as a common configuration flag for the class.
2. Explain the rules and mechanism of function overloading with appropriate examples. [5 Marks]
Answer:
Definition
Function overloading allows a single function name to perform different tasks based on the number or type of arguments provided.
Rules for Overloading
- Different number of arguments: Function func(int) vs func(int, int).
- Different types of arguments: Function func(int) vs func(double).
- Sequence of types: Function func(int, double) vs func(double, int).
Example
Consider a function 'display'. One version takes an integer: void display(int i). Another version takes a double: void display(double d). During a call, the compiler matches the passed value type to the correct function definition at compile-time.
Conclusion
Overloading improves code readability and reusability by providing a consistent interface for operations that perform similar actions on different data types.
3. Describe the features and limitations of static member functions. [5 Marks]
Answer:
Features
- Class-wide access: These functions belong to the class and can be called without needing an object instance.
- Access Scope: They can only access other static data members or other static member functions.
- Efficiency: They are useful for utility functions that perform tasks related to the class but do not need to operate on specific instance data.
Limitations
- No 'this' pointer: Because they are not bound to an instance, they cannot use the implicit 'this' pointer.
- Non-static data: They cannot access non-static data members because the function does not know which object's data to access.
- Virtual functions: Static member functions cannot be declared as virtual.
Conclusion
Static member functions act as a bridge to manage shared class resources efficiently while maintaining encapsulation within the class structure.
4. Compare static data members and static member functions. [5 Marks]
Answer:
| Feature | Static Data Member | Static Member Function |
|---|---|---|
| Purpose | To store shared class state. | To perform shared class operations. |
| Access | Stores values (int, float, etc.). | Executes code/logic. |
| Invocation | Accessed via ClassName::variable. | Called via ClassName::function(). |
| Requirement | Must be defined outside the class. | Defined inside the class like normal functions. |
| Access Rules | Can be modified by non-static functions. | Cannot access non-static class members. |
Summary
Both tools serve the purpose of organizing class resources that are independent of individual objects. While the data member holds the shared state, the static function provides the mechanism to interact with that state.
5. Discuss the importance of function overloading in object-oriented programming. [5 Marks]
Answer:
Importance
Function overloading is a form of compile-time polymorphism that increases the flexibility of code. It allows developers to create intuitive interfaces where the logic adapts to the input data.
Advantages
- Code Readability: Users do not need to memorize different function names for similar tasks (e.g., using print(int), print(float), and print(string) instead of printInt, printFloat, and printString).
- Consistency: It allows the implementation of cleaner and more standardized code structures.
- Maintenance: Adding new data types for an operation simply involves overloading the existing function name, keeping the API simple.
Implementation Logic
The compiler determines which function to call by analyzing the 'function signature', which consists of the function name and the parameter list. This mapping happens before the program runs, ensuring no runtime performance overhead.
Conclusion
Function overloading is a fundamental concept that enables clear, logical, and compact code, making software easier to write and maintain.