Thread: Returning a Dynamic array of pointers

I'm having trouble picturing what this looks like in memory which is one of problems. Maybe someone can help me out.

Code:

#include <iostream> 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string>

using namespace std;


typedef struct {
        char* name;   
	int number;
    } SomeStruct;

//function prototypes
  char * getbuf(SomeStruct ***ptrs);
  SomeStruct * GetNextSomeStruct(void);


 


 int main()
 {
	 

	// array of pointers to SomeStruct
	 SomeStruct **array_ptrs = NULL;
 
	  
 	char * b, q, *r;	   
	
	  
	b=getbuf(&array_ptrs);	
        //I want to do something like this 
         //to fill the array_ptrs with data but I keep getting errors
	//array_ptrs[2][1] = GetNextSomeStruct();  
       //I tried to test it like this but it crashes here too 
array_ptrs[2][1].number = 8;    
                                                      
	 
  
	  q = *b;	  
	
 	 
 

 		 
 }
char * getbuf(SomeStruct ***ptrs)	   
 	{	  
		 
	 
		char buff[8] ;	   
 	 	
		//int n = 5; //can also be determined by user at runtime
		 
 
  //   allocate the memory for the array  

      
	   
   int m;
	*ptrs = (SomeStruct**)malloc(  sizeof( SomeStruct* )* n );
   for (m = 0; m < 1; m++)
    {
     (*ptrs)[m] = (SomeStruct*)malloc( sizeof( SomeStruct ) * n );
     }
   
   

 
 
	return  (char *)  buff;	   
 	}


 



    // Return the next structure (to fill the 
     //                          abovementioned array with).
     
      
    SomeSeq * GetNextSomeStruct()
	  {
                //I don't really know what I should do here
                //create some data and then return it to 
                //array_ptrs in main.
		SomeStruct *p=NULL;
		 
		 
		p  = (SomeStruct*)malloc( sizeof( SomeStruct* ) );
		  

			
		return p ;
	  }

Why don't you start by properly indenting and whitespacing your code. What you show here is NOT legible, which may be part of your confusion.

Is this better?

Code:

#include <iostream> 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string>

using namespace std;


typedef struct {
        char* name;   
	int number;
    } SomeStruct;

//function prototypes
char * getbuf(SomeStruct ***ptrs);
SomeStruct * GetNextSomeStruct(void);


 int main()
 {
	 // array of pointers to SomeStruct
	 SomeStruct **array_ptrs = NULL;
 
	 char * b, q, *r;	   
	
	  
	b=getbuf(&array_ptrs);	
        //I want to do something like this 
        //to fill the array_ptrs with data but I keep getting errors
	//array_ptrs[2][1] = GetNextSomeStruct();  
       	//I tried to test it like this but it crashes here too 
	array_ptrs[2][1].number = 8;    
                                                      
	q = *b;	  
	
 	 
}


char * getbuf(SomeStruct ***ptrs)	   
{	  
		 
	 char buff[8] ;	   
 	 int n = 5; //can also be determined by user at runtime
		 
 
  	//allocate the memory for the array  
	int m;
	*ptrs = (SomeStruct**)malloc(  sizeof( SomeStruct* )* n );
   		for (m = 0; m < 1; m++)
    			{
     				(*ptrs)[m] = (SomeStruct*)malloc( sizeof( SomeStruct ) * n );
     			}
   
   	return  (char *)  buff;	   
 }


 



// Return the next structure (to fill the 
// abovementioned array with).
     
      
SomeSeq * GetNextSomeStruct()
{
     //I don't really know what I should do here
     //create some data and then return it to 
     //array_ptrs in main.
	SomeStruct *p=NULL;
		 
		 
	p  = (SomeStruct*)malloc( sizeof( SomeStruct* ) );
	// fill this with data and return

			
	return p ;
}

That indentation isn't completely awful, thanks for that.

So what do you think this does:

Code:

char * getbuf(SomeStruct ***ptrs)	   
{	  
		 
	 char buff[8] ;	   
 	 int n = 5; //can also be determined by user at runtime
		 
 
  	//allocate the memory for the array  
	int m;
	*ptrs = (SomeStruct**)malloc(  sizeof( SomeStruct* )* n );
   		for (m = 0; m < 1; m++)
    			{
     				(*ptrs)[m] = (SomeStruct*)malloc( sizeof( SomeStruct ) * n );
     			}
   
   	return  (char *)  buff;	   
 }

and why do you think it has any relation to making an m x n array? And why are you returning an invalid pointer to a local object?

I guess thats my problem, thats the best that I can come up for making an array of pointers , it seems to work to some extent but I am lost on some it. As far as the return char buff, thats the instructions I have. The function must return that but also return an array of pointers to SomeStruct's.

The function can not return two things. Either your instructions are impossible to achieve, or you are misreading them. (Since buff does not appear anywhere, or do anything, it's existence is extremely hard to justify.)

If you wanted to make an array of pointers, you would not need a *** variable. You're also not even trying to make an array of pointers; you appear to be trying to make a dynamic two-dimensional array. If so, then I suggest you think about what the word two-dimensional means, and what the two dimensions of your array are supposed to be.

Here is an array of pointers
Somestruct *arrayOFpointers[10]; //Not dynamic
So I did this:
Somestruct **arrayOFpointers; //is this a dynamic array of pointers? I don't know.
What I mean by returning this is gaining access to the array without actually using the return keyword.

I mean passing in by reference and then changing it, as I did in the code. That way I can effectively "return" the array. As far as the way I allocated the memory for the array of pointers that is correct isn't it?

I know the program doesn't make it sense. It an assessement of my skills to see if I can do it, I am free to ask for help however. If I allocated it correctly then why am I unable to access the array back in main? Like this:
array_ptrs[2][3].number = 5;

I would recommend that you pass in an array of SomeSeq stuff and then do input on that.

If you arrange for values in your main data array that stand for an empty or unused space, you could have the function search for an empty space and put the valid input there. I don't really know what these values should be, but for example, "" for name and -1 for number.

On what you currently have for this: while it's probably not a big deal, I don't see the point in allocating more memory in your function and then waiting to do the assignment to your actual array. I think as written it's leaking memory anyway.

Yeah I agree it is overkill, I just couldn't think of any other way. I try some of your suggestions. Thanks