Question

Hello I need help with this questions about C++ programming

- If a function is called and passed a pointer variable as a parameter, how must that pointer variable be passed if the function is to modify its contents?

- When must a class provide a getter for a member variable?

- An inline function saves processing time, but at what expense?

Answer 1

1. If a function is called and passed a pointer variable as a parameter, how must that pointer variable be passed if the function is to modify its contents?

Function is called and passed a pointer variable as a parameter. In order for the passed pointer variable to be modifiable we need to pass the pointer with a non-const modifier so that the pointer can be modified within the function.Also the variable passed must also be non-const type, as modifier const doesn't allow the variables to be modified. If we call the function using a non-pointer variable , we need to pass the variable using the reference so that the address of the variable is passed to the function rather than the value.Similarly, if we pass a pointer type to the function, we need to pass the pointer name without any asterisk(*) as pointer name refers to the memory address of the variable and * refers to the variable stored in the variable.

Eg: Suppose we have the below function which is passed a pointer variable such that the pointer variable can be modified within the function:

// the pointer must not contain const keyword as we need to modify the pointer within the function
void func1(int *p)
{
   *p = *p+5; // we add 5 to the existing contents of pointer value
}

// Calling the function
int main()
{
   int a = 10;
   int *p = &a; // p is pointing to a i.e memory address of a. It must be of non-const type
   // calling the function using the pointer variable
   // p refers to the address of a
   func1(p) ;
   // calling the function using the regular variable
   // address of a is passed to the function
   funct1(&a);
   return 0;
}

2. When must a class provide a getter for a member variable?

A class must provide a getter for a member variable when it is declared in non-public(private or protected) visibility mode. As only public variables are directly accessible by the objects of the class. The private members of the class are only accessible by the member functions of the class and protected members are accessible by the class member functions or its derived class's member functions.
Eg-

class Sample
{
private :
   int a;
protected:
   int b;

public:
   int c;
   Sample() : a(2), b(3), c(5)
   {}
  
   int getA() { return a;}
   int getB() { return b; }  
      
};

In the above class Sample, getters for member variables a and b are required as the objects of class Sample cannot directly access them but c being in public visibility mode is directly accessible by the objects of class Sample and hence getter for member variable c is not necessary

3. An inline function saves processing time, but at what expense?

An inline function is a function for which the function call is replaced by the function definition in compile time i.e the compiler replaces all the function call in the program by its function definition. This saves processing time as it reduces the function call overhead time because at the time of function call it doesn't have to refer to the memory address where the function is defined.
The variables used in function is also increased and hence the registers used for the calculation is increased. This leads to increase in variable numbers. For small functions , making it inline doesn't affect the size of the program much and hence can be ignored. But if a large function is made inline then the size of the program and hence the executable will be large. Also if a number of smaller functions are made inline then the total effect of these functions on the executable will be large. Also inline functions may reduce the run time of the program but the compile time of the program.