Passing char* [] to a function which accepts char** as arguments

Question

I have written a program which sorts command line arguments. However, when I am trying to print the output(using a function), I am not able to do it.Because I am trying to pass char *[] in a function which accepts char** as argument. After a lot of searching, which resulted in nothing much, I am hence here with my first question in SO.

#include "iostream"
#include "cstdlib"
#include "cstring"
using namespace std;


void sortArgs();
int stringcomp (const void * x, const void * y);
void parse(char **argv, int argc);
void printArgs();
void setArgs(char **argv, int argc);

int size;
char** argNew;

int main (int argc, char** argv) 
{

parse(argv, argc);
printArgs();

return 0;

}

int stringcomp (const void *x, const void *y) 
{
    return strcmp (*(char * const *)x, *(char * const *)y);
}

void parse(char **argv, int argc)
{
   setArgs(argv, argc);
   sortArgs();
}


void setArgs(char **argv, int argc)
{
   argNew=argv;
   size=argc;
}

void  printArgs()
{

  char *s[size-1];
  cout<<size<<endl;

  for (int i = 1; i < size; i++)
  {
      s[i-1] = argNew[i];

  }

   for (int i = 0; i < size-1; i++)
        cout<<" "<< s[i];
   cout <<endl;
}

void sortArgs()
{


    int i;
    char *strings[size-1];

    /* assign each argument to a pointer */
    for (i = 1; i < size; i++)
    {
        strings[i-1] = argNew[i];
    }

    /* sort the array of pointers alphabetically with qsort */
    qsort (strings, size - 1, sizeof *strings, stringcomp);

    for (int i = 0; i < size-1; i++)
    cout<<" "<< strings[i];  //this prints the output just fine  


    setArgs(strings, size);    // pass the *strings[] here


 }

I am trying to pass strings in the function- setArgs() from the function sort(). Later when I use it to print the array, it gives me seg fault. Can anyone please help me visualize/rectify the problem here ?

---

PS: I understand that I can print the char* strings[] in the sort method itself, but my main focus is how to pass it to a function which accepts char** as argument.

Answer 1

You're assignment through setArgs from sortArgs is storing the base address of the automatic variable strings into a global. Once sortArgs exits and control is returned to parse, that array no longer exists. Any evaluation or dereference therein invoke undefined behavior.

You could fix this (term used loosely, see next section for why) by simply sticking with argv and argc set into your globals, and sort those, not some arguments passed in to some functions. Or you could copy the pointers to a pointer-bed like you're doing now, then sort them, then copy them back out to argvNew.

Or you would eliminate the globals entirely and throw out the set ideology in the process, simply having parse sort the pointers within argv directly You can't do much with it, but you can reorder it and still say in the realm of defined behavior.

But why? This is after, C++.

Jumping Into The C++ Pool

I'm not going to sugarcoat this. The code is dreadful. It is trying desperately to walk in the land of C++ using as little C++ standard library offerings as possible besides basic IO. C is a great language, and has a stellar, well-honed standard library, but if you want to dive into C++, then don't fear it; embrace it.

To do this in C++, consume some fundamental C++ standard library offerings. One could do things considerably differently. For example:

1. Load a std::vector<std::string> from argv and argc
2. Do whatever you want to that, including sorting it.

That code is far simpler than you may think:

#include <iostream>
#include <vector>
#include <string>

std::vector<std::string> parseArgs(char **argv, int argc)
{
    std::vector<std::string> args(argv+1, argv+argc);
    std::sort(args.begin(), args.end());
    return args;
}

int main (int argc, char** argv)
{
    auto args = parseArgs(argv, argc);

    // move to your own function.
    for (auto const& s : args)
        std::cout << s << '\n';

    return 0;
}

Answer 2

setArgs(strings, size);    // pass the *strings[] here

That's the mistake.

strings is a local array. It gets deleted when the function returns. As a consequence, argNew will be a dangling pointer when the function returns. Trying to print the contents of argNew is undefined behavior.

Replace that line by copying the elements of strings to argNew.

for (i = 1; i < size; i++)
{
   argNew[i] = strings[i-1];
}

Answer 3

There are many good searches such as "double pointers c" on StackOverflow or Google. E.g. c/c++ questions on pointers (double pointers) and http://www.cplusplus.com/doc/tutorial/pointers/ .

That said, the number one thing I'd suggest is that you can print a pointer's value just like a number. To do this either write:

printf("Pointer is %p.\n", ptr);

or:

std::cout << "Pointer is " << (void *)ptr << ".\n";

You can then analyze the output of the following:

#include <iostream>

// Sometimes it's char *, sometimes const char *
template <typename T>
void print_argv_style_array(const char *label, int argc, T **argv) {
    int i = 0;
    std::cout << label << ": Printing argv array of size " << argc << " at " << (void *)argv << ":\n";
    for (int i = 0; i < argc; i++) {
    std::cout << "    " << i << ": " << (void *)argv[i] << " -- " << argv[i] << "\n";
    }
}

void f1() {
    const char *strings[] = { "foo", "bar" , "baz" };
    print_argv_style_array("f1", sizeof(strings) / sizeof(strings[0]), strings);
}

void f2() {
    const char *strings[] = { "foo", "bar" , "quux" };
    print_argv_style_array("f2", sizeof(strings) / sizeof(strings[0]), strings);
}

const char *global_array[] = { "foo", "bar", "baz" };
const char **global_ptr = global_array;

int main(int argc, char **argv) {
    std::cout << "main: argv is at " << &argv << "\n";
    print_argv_style_array("main", argc, argv);
    f1();
    f2();
    std::cout << "global_array is at: " << (void *)global_array << "\n";
    print_argv_style_array("global_array", sizeof(global_array)/sizeof(global_array[0]), global_array);
    std::cout << "global_ptr is at: " << (void *)&global_ptr << "\n";
    print_argv_style_array("global_ptr", sizeof(global_array)/sizeof(global_array[0]), global_ptr);
}

Which on my system looks like:

main: argv is at 0x7fff5a8c38f0
main: Printing argv array of size 1 at 0x7fff5a8c3928:
    0: 0x7fff5a8c3ab8 -- ./pointer_help
f1: Printing argv array of size 3 at 0x7fff5a8c38a0:
    0: 0x10533dedc -- foo
    1: 0x10533dee0 -- bar
    2: 0x10533dee4 -- baz
f2: Printing argv array of size 3 at 0x7fff5a8c38a0:
    0: 0x10533dedc -- foo
    1: 0x10533dee0 -- bar
    2: 0x10533deeb -- quux
global_array is at: 0x10533e140
global_array: Printing argv array of size 3 at 0x10533e140:
    0: 0x10533dedc -- foo
    1: 0x10533dee0 -- bar
    2: 0x10533dee4 -- baz
global_ptr is at: 0x10533e158
global_ptr: Printing argv array of size 3 at 0x10533e140:
    0: 0x10533dedc -- foo
    1: 0x10533dee0 -- bar
    2: 0x10533dee4 -- baz

Notice that the locations of the strings arrays are the same for f1 and f2. (This is not guaranteed, it just happens to be the case here. It is certainly often true however and is useful to understand re: the SEGV bug you were seeing.) Note that string literals "foo", "bar", and "baz" get pooled -- that is there is only one copy of them even though they are used more than once. The sequence of string pointer values is consistent with the linker laying them out in order in memory as well.

Notice that &global_array is the same value as global_array, but this is not the case with global_ptr.