1. What is nullptr in C++?
(A) Null integer
(B) Null pointer constant
(C) Null reference
(D) Garbage value
2. Which of the following is correct to assign nullptr to a pointer?
(A) int *p = 0;
(B) int *p = nullptr;
(C) int *p = NULL;
(D) All of the above
3. What is the type of nullptr?
(A) int
(B) void*
(C) std::nullptr_t
(D) char*
4. What does new int; do?
(A) Allocates memory for int on stack
(B) Allocates memory for int on heap and returns pointer
(C) Declares int variable
(D) None of these
5. How do you deallocate memory allocated by new?
(A) free()
(B) delete
(C) remove()
(D) release()
6. How do you allocate an array of 5 integers on heap?
(A) int *arr = new int[5];
(B) int arr[5];
(C) int *arr = malloc(5);
(D) int *arr = new int;
7. How do you free memory allocated for an array?
(A) delete arr;
(B) delete[] arr;
(C) free(arr);
(D) release(arr);
8. What is the difference between NULL and nullptr?
(A) NULL is integer 0, nullptr is pointer type
(B) NULL is safer than nullptr
(C) nullptr is obsolete
(D) None
9. What happens if you delete a nullptr?
(A) Runtime error
(B) Compile-time error
(C) Safe, does nothing
(D) Undefined behavior
10. What is wrong with this code?
int *p = new int;
delete p;
delete p;
(A) Compile-time error
(B) Runtime error (double delete)
(C) Correct code
(D) Warning only
11. Which of the following is correct dynamic memory allocation for a double variable?
(A) double *d = new double;
(B) double d = new double;
(C) double *d = double();
(D) double *d = malloc(sizeof(double));
12. Which operator allocates memory and calls constructor for class objects?
(A) malloc
(B) new
(C) delete
(D) free
13. Which operator calls destructor and frees memory?
(A) free
(B) delete
(C) new
(D) malloc
14. What happens if you do not delete dynamically allocated memory?
(A) Memory leak
(B) Compile error
(C) Runtime error
(D) Nothing
15. Which is correct way to allocate memory for an array of objects?
(A) MyClass *arr = new MyClass[10];
(B) MyClass arr[10];
(C) MyClass *arr = malloc(10 * sizeof(MyClass));
(D) MyClass arr = new MyClass[10];
16. Can you assign nullptr to any pointer type?
(A) Yes
(B) No
(C) Only int pointers
(D) Only class pointers
17. What is output?
int *p = nullptr;
if(p) cout << "Not null";
else cout << "Null";
(A) Not null
(B) Null
(C) Garbage
(D) Compile error
18. Dynamic memory for objects of class is created using?
(A) malloc
(B) new
(C) calloc
(D) free
19. How do you delete a single object dynamically allocated?
(A) delete obj;
(B) delete[] obj;
(C) free(obj);
(D) release(obj);
20. What happens if delete[] is used on single object allocated by new?
(A) Correctly deletes object
(B) Undefined behavior
(C) Compile-time error
(D) Throws exception
21. How do you dynamically allocate a 2D array?
(A) int arr = new int[rows]; for(int i=0;i<rows;i++) arr[i] = new int[cols];
(B) int arr[rows][cols];
(C) int **arr = malloc(rowscols);
(D) int arr = new int[rowscols];
22. Can nullptr be compared with NULL?
(A) Yes
(B) No
(C) Only in C++11
(D) Only for pointers to int
23. What is advantage of nullptr over NULL?
(A) Type-safe
(B) Safer for overload resolution
(C) Avoids ambiguity
(D) All of the above
24. Which is correct syntax for new object with constructor?
(A) MyClass *obj = new MyClass();
(B) MyClass obj = new MyClass();
(C) MyClass *obj = malloc(sizeof(MyClass));
(D) MyClass *obj = MyClass();
25. What is wrong with code?
int *p;
delete p;
(A) p is uninitialized, delete causes undefined behavior
(B) Correct
(C) Compile-time error
(D) Deletes nullptr
26. What is correct way to free dynamically allocated 2D array?
(A) delete[] arr;
(B) for(i=0;i<rows;i++) delete[] arr[i]; delete[] arr;
(C) free(arr);
(D) delete arr;
27. Which of the following is NOT allowed?
(A) int *p = nullptr;
(B) delete nullptr;
(C) int a = nullptr;
(D) nullptr comparison with pointer
28. Which operator allocates memory but does NOT call constructor?
(A) new
(B) malloc
(C) new[]
(D) delete
29. Which of the following is valid initialization of pointer using nullptr?
(A) int *p = nullptr;
(B) char *c = nullptr;
(C) double *d = nullptr;
(D) All of the above
30. What is correct to prevent memory leak?
(A) Use delete/delete[] for every new/new[]
(B) Avoid using new
(C) Use malloc/free instead
(D) Assign nullptr to pointers