Thread: Passing my array to function

Passing functions utilize the unary operator “&”. To do this properly, you would send the address of a single row of your two-dimensional pointer:

Code:

translate(&args[n]);

Instead of:

Code:

translate(*args);

*args will result in an error as it may already since args is a char **, and you would have to send the memory address of args[] to translate since it only recognizes a single string, not multi-dimensional.


char **args is in the same dimension as:

Code:

int myValue[2][3] = { {5, -3, 0}, {10, 17, -25} };

Which consists of rows and columns, instead of just a single row and column. To get a better look, this initialization can be viewed as:

Code:

Rows/Columns	Column 0	Column 1	Column 2
Row 0		5		-3		0
Row 1		10		17		-25

It is unlikely your function translate() will take all the rows and n amount of columns by sending it to a single char * called input. That's why sending the memory address of args[] is beneficial. args[] already holds a single row and column per array index.

On further note, the unary operator “&” gives the memory address of an existing object. This assigns the address of one variable and “points to” or “passes to” another.

I can further expound if neccessary.

Edit: You many not need to send the memory address of args[n] to translate() if not needed.


- Stack Overflow

I'm afraid I must disagree.

Code:

#include <stdio.h>

void argtest( char * arg )
{
        printf("arg is %s\n", arg );
}

int main( void )
{
        char **args;
        char *s[] = { "Hello", "World", "!", 0 };
        args = s;
        while( *args )
        {
                argtest( *args++ );
        }
        return 0;
}
/*
arg is Hello
arg is World
arg is !
*/

Dereferencing a pointer to a pointer to a type, gives you a pointer to a type, which is exactly what the function calls for.

Quzah.

How do you think you'd past a char ** to a function?
If you can pass a char * to this prototype:

Code:

void foo( char * );

Then what would you need for a char **? Take a second and think about it. It's not hard.

Quzah.

Close, but you're passing it wrong.

Q) How do you pass a character pointer to a function that wants one?
A) By passing the name of a variable:

Code:

void foo( char * );

int main( void )
{
    char *s = "Hello World!";
    foo( s );
    return 0;
}
...

The same holds true for a pointer to a pointer. If the variable you have to pass is exactly what the function expects, you simply pass it's name over.

Quzah.

Quzah, I love you, if I were a woman and I assume you are a man, I would marry you . You have been a great help to me, thank you very much.

here's the first major problem:

Code:

while(csh != NULL)
	{
	  args = realloc(args, sizeof(char *)*(nargs + 1));
	  args[nargs] = malloc(strlen(csh) + 1);
	  strcpy(args[nargs], csh);
	  nargs++;

	  csh = strtok(NULL, " ,\n");
	}

each iteration of the loop you reallocate the char ** meaning when the loop finishes, only the last char * in the array points to valid memory. it doesn't help that you don't even free the memory when you're done with it, either!

>> translate(*args);

the way you have it here only one command gets executed - you'll need to either set up a loop to call the function with or else redesign the function to process a char ** internally.

this is a good example of why it is so important to modularize code as much as possible. just start with the obvious - you need an array of char * and also a means for safely destroying the array when you're done with it. so start with a set of functions:

Code:

/*
 DeleteMatrix() takes the address of a char **
 so that it can set the pointer to NULL internally.
*/
void DeleteMatrix(char *** array, int rows) {
 if(*array != NULL) {
  int index;
  for(index = 0; index < rows; ++index) {
   free((*array)[index]);
   }
  free(*array);
  *array = 0;
  }
 return;
 }
/*
 NewMatrix() allocates an extra row which is set to
 NULL - this makes traversing the array easier...
 also, each column gets an extra char for posterity.
*/
char ** NewMatrix(int rows, int columns) {
 char ** array = malloc(rows+1);
 if(array != NULL) {
  array[rows] = NULL;
  int index;
  for(index = 0; index < rows; ++index) {
   array[index] = malloc(columns+1);
   if(array[index] == NULL) {
    DeleteMatrix(&array, index);
    }
   }
  }
 return array;
 }

putting all the 'guts' of the code within functions really can make coding a lot easier to develop and debug. make a list of repetitive tasks and start building a toolkit of useful functions - you won't regret it.

[edit]
foiled!
[/edit]