Declare A Cc++ Function Returning Pointer To Array Of Integer Pointers

In this guide, we will explore the process of defining a C/C++ function that returns a pointer to an array of integer pointers.

Create a function that takes an integer pointer as an argument and produces a pointer to an array containing four integer pointers.

Even though it might seem complex initially, we can define the necessary function by breaking down a series of statements.

1. A function with the parameter int * is needed.
2. This function is designed to accept an integer pointer as an argument and then provide a pointer as the return value.

(function(int )) is a function that takes an argument of type int * and returns a pointer to an array of 4 elements.

(function(int ))

1. A function that takes an integer pointer as an argument and produces a pointer to an array containing four integer pointers

int (function(int *))[4];

How can we ensure the accuracy of the previous statement? The subsequent software can confirm the correctness of our assertion.

Code(syntax):

#include<stdio.h>

#define SIZE_OF_ARRAY (4)

typedef int *(*p_array_t)[SIZE_OF_ARRAY];

int *(*function(int *arg))[4];

p_array_t function(int *arg)
{
static int *arr[SIZE_OF_ARRAY] = {NULL};

p_array_t pRet = &arr;
return pRet;
}
int main()
{		
}

The macro SIZEOFARRAY is utilized to symbolically represent the size of an array. The definition of parrayt specifies it as a "pointer to an array containing four integers." In case our declaration is inaccurate, the program will halt at the point where the 'function' is defined.

Part 2: The objective is to create a function using the given array that will return a pointer to an array of function pointers for integers.

For this task, we will input two values, run a function to compare them, and then employ a function pointer to determine the memory address of the greater value before displaying the outcome. The flexibility and abstraction of functions are enhanced by utilizing function pointers to supply different function addresses dynamically. As a result, function pointers offer a direct approach for selecting which function to execute based on real-time data, thereby streamlining the code.

Illustration of the big function

The big function is invoked by the application and accepts two integer values by reference. It evaluates the two values and provides the memory address of the greater number. This function returns an integer value, which can be a non-zero or zero value.

For instance,

Input ? 8 14
Output ? Bigger value is 14
Input ?5 9
Output? Bigger value is 9

Analysis: Upon evaluating the two integer values provided, the pointer will indicate the memory address associated with the larger value.

A method that could be used

• ✅ Consider the integer pointer int *c.
• ✅ The two integer variables should be initialised.
• ✅ We will enter the two values.
• ✅ Comparing the two values provided.
• ✅ Pointer *c finally returns the address of a larger value.

Algorithm

Start
STEP 1-> Pass the argument to the function after creating it.
   Int *big(int &, int &)
END
STEP 2-: calling the main() function to initialise the pointer *c and enter and output two values.
   int p, q, *c
   call c= big(p,q)
   print c
END
STEP 3-> Pointer c returns the memory address of the larger value after comparing the two integer values given to it.
   Comparing
   If(a>b)
      return(&a)
   else
      return(&b)
   END
STOP

C++ Code:

#include<iostream.h>
int *big(int&, int&);
int main( ){
   int p, q, *c;
   c= big(3, 9);
   cout<<"The bigger value is"<<*c;
";
   return 0;
}
int *big(int&a, int&b){
   if(a>b)
      return(&a);
   else
      return(&b);
}

Output:

Executing the code provided above will lead to the following output being displayed.

The bigger value is 9