Passing a command into a shell script through a C++ program

If you just want to call "./script" with the first argument to the C++ program passed as the first argument to the script, you could do it like this:

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

int main(int argc, char ** argv)
{  
   if (argc < 2)
   {  
      printf("Usage:  ./MyProgram the_argument\n");
      exit(10);
   }

   std::string commandLine = "./script ";
   commandLine += argv[1];

   std::cout << "Executing command: " << commandLine << std::endl;
   system(commandLine.c_str());
   return 0;
}

Properly executing a shell command from C++ actually takes quite a bit of setup, and understanding exactly how it works requires a lot of explanation about operating systems and how they handle processes. If you want to understand it better, I recommend reading the man pages on the fork() and exec() commands.

For the purposes of just executing a shell process from a C++ program, you will want to do something like so:

#include <unistd.h>
#include <iostream>

int main() {
    int pid = fork();
    if (pid == 0) {
        /*
         * A return value of 0 means this is the child process that we will use
         * to execute the shell command.
         */
        execl("/path/to/bash/binary", "bash", "args", "to", "pass", "in");
    }

    /*
     * If execution reaches this point, you're in the parent process
     * and can go about doing whatever else you wanted to do in your program.
     */
    std::cout << "QED" << std::endl;
}

To (very) quickly explain what's going on here, the fork() command essentially duplicates the entire C++ program being executed (called a process), but with a different value of pid which is returned from fork(). If pid == 0, then we are currently in the child process; otherwise, we're in the parent process. Since we're in the dispensable child process, we call the execl() command which completely replaces the child process with the shell command you want to execute. The first argument after the path needs to be the filename of the binary, and after that you can pass in as many arguments as you want as null-terminated C strings.

I hope this helps, and please let me know if you need further clarification.

the problem I have understood so far is that you want to pass arguments to c++ executable and it will then pass those arguments further to the system script

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

using namespace std;

// argc is the count of the arguments
// args is the array of string (basically the arguments)

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

   // Convetion to check if arguments were provided
   // First one or two are the not positional. (these are information related to the binary that is currently being executed)
   if (argc < 2) {
      printf("Please Provide an Argument");
      return 100; // Any number other than 0 (to represent abnormal behaviour)
   }

   string scriptCommand = "./name-of-script"; // script in your case

   // Loop through and add all the arguments.
   for (int i = 1; i < argc; i++)
      scriptCommand += " " + argv[i];

   system(scriptCommand.c_str());
   return 0; // Represents a normal exit (execution).
}