Run a program from within a program

Having said that, it is easy to use, and these things have their place. Here is a example of how to use it.

/*
 * This example assumes the program you want to execute
 * is called child.exe, and resides in the same 
 * directory as this program
 */

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

int main()
{
  char child1[] = "child.exe";
  char child2[BUFSIZ];
  
  /* 
   * Execute by passing the name directly 
   */
  system ("child.exe");
  
  /*
   * Execute by passing an array name
   */
  system (child1);
  
  /*
   * Build a buffer, and execute the commands within it
   */
  strcpy (child2, "child.exe");
  strcat (child2, " -aparm -b");
  
  printf ("Executing %s\n", child2);
  system (child2);
  
  return 0;
}

/*
 * Program output:
 I am the child
 I am the child
 Executing child.exe -aparm -b
 I am the child
 Arg 1 -aparm
 Arg 2 -b
 *
 */

OPTION 2 - spawn

There a family of functions collectively known as spawn. These are:

#include <process.h>
int spawnl(   mode, path, arg0, arg1..., argn, 
              NULL );
int spawnle(  mode, path, arg0, arg1..., argn, 
              NULL, envp);
int spawnlp(  mode, file, arg0, arg1..., argn, 
              NULL );
int spawnlpe( mode, file, arg0, arg1..., argn, 
              NULL, envp);
int spawnv(   mode, path, argv );
int spawnve(  mode, path, argv, envp );
int spawnvp(  mode, file, argv );
int spawnvpe( mode, file, argv, envp );

int         mode;      /* mode for parent      */
const char *path;      /* file name incl. path */
const char *file;      /* file name            */
const char *arg0,..., 
           *argn;      /* arguments            */
char *const argv[];    /* array of arguments   */
char *const envp[];    /* environment strings  */

These functions create and execute a new child process, named by path or file (depending on the form of the function used). The value of mode determines how the program is loaded, and how the parent program will behave after the child program is initiated.

P_WAIT
The child program is loaded into memory and executed, and then the parent program resumes execution.
P_NOWAIT
Causes the parent program to execute concurrently with the new child process.
P_NOWAITO
Causes the parent program to execute concurrently with the new child process. The wait() function cannot be used to obtain the exit code.
P_OVERLAY
The child program replaces the parent program in memory and is executed. No return is made to the parent program.

The various forms of the spawn functions are:

#include <stdio.h> 
#include <process.h> 

int main(void)
{
  
  puts("Spawning child with spawnl");
  
  spawnl( P_WAIT, "child.exe",
    "child.exe", "Using spawnl", "Arg1", "Arg2", NULL );
    
  return 0;
}

/*
 * Program output:
 Spawning child with spawnl
 I am the child
 Arg 1 Using
 Arg 2 spawnl
 Arg 3 Arg1
 Arg 4 Arg2
 *
 */

#include <stdio.h> 
#include <process.h> 

int main(void)
{
  char *my_args[4];
  
  my_args[0] = "child.exe";
  my_args[1] = "arg1";
  my_args[2] = "arg2";
  my_args[3] = NULL;
  
  puts("Spawning child with spawnv");
  
  spawnv( P_WAIT, "child.exe", my_args);
    
  return 0;
}

/*
 * Program output:
 Spawning child with spawnv
 I am the child
 Arg 1 arg1
 Arg 2 arg2
 *
 */
 

OPTION 3 - fork/exec

Using a combination of fork and exec, you can duplicate your running program in memory, then turn the second copy into another program altogether.

Prototypes:
#include <sys/types.h>
#include <unistd.h>
pid_t fork( void );

The exec family consists of:

#include <unistd.h>
int execl(   path, arg0, arg1..., argn, NULL );
int execle(  path, arg0, arg1..., argn, NULL,
             envp );
int execlp(  file, arg0, arg1..., argn, NULL );
int execlpe( file, arg0, arg1..., argn, NULL,
             envp );
int execv(   path, argv );
int execve(  path, argv, envp );
int execvp(  file, argv );
int execvpe( file, argv, envp );

const char *path;     /* file name incl. path */
const char *file;     /* file name            */
const char *arg0,..., 
           *argn;     /* arguments            */
char *const argv[];   /* array of arguments   */
char *const envp[];   /* environment strings  */

#include <stdio.h> 
#include <stdlib.h> 
#include <sys/types.h>
#include <unistd.h> 


int main(void)
{
  char *my_args[5];
  pid_t pid;
  
  my_args[0] = "child.exe";
  my_args[1] = "arg1";
  my_args[2] = "arg2";
  my_args[3] = NULL;
  
  puts ("fork()ing");
  
  switch ((pid = fork()))
  {
    case -1:
      /* Fork() has failed */
      perror ("fork");
      break;
    case 0:
      /* This is processed by the child */
      execv ("child.exe", my_args);
      puts("Uh oh! If this prints, execv() must have failed");
      exit(EXIT_FAILURE);
      break;
    default:
      /* This is processed by the parent */
      puts ("This is a message from the parent");
      break;
  }
  
  puts ("End of parent program");
  return 0;
}

/*
 * Program output:
 fork()ing
 This is a message from the parent
 End of parent program
 I am the child
 Arg 1 arg1
 Arg 2 arg2
 *
 */

Further options

Windows options: (Credit: Sunlight) Use one of the _spawn functions, or CreateProcess, or ShellExecute. Which one you use depends on what you want to do. _spawn is simplest (and most portable), CreateProcess gives you the most control, ShellExecute gives you the most flexibility (starts documents as well as files, for example).

Here are some examples of Windows versions, compliments of Fordy.

Using CreateProcess()

#include <windows.h> 

int main(void)
{
  char szPath[] = "C:\\WINDOWS\\system32\\Calc.exe";
  PROCESS_INFORMATION pif;  //Gives info on the thread and..
                           //..process for the new process
  STARTUPINFO si;          //Defines how to start the program

  ZeroMemory(&si,sizeof(si)); //Zero the STARTUPINFO struct
  si.cb = sizeof(si);         //Must set size of structure

  BOOL bRet = CreateProcess(
        szPath, //Path to executable file
        NULL,   //Command string - not needed here
        NULL,   //Process handle not inherited
        NULL,   //Thread handle not inherited
        FALSE,  //No inheritance of handles
        0,      //No special flags
        NULL,   //Same environment block as this prog
        NULL,   //Current directory - no separate path
        &si,    //Pointer to STARTUPINFO
        &pif);   //Pointer to PROCESS_INFORMATION

  if(bRet == FALSE)
  {
    MessageBox(HWND_DESKTOP,"Unable to start program","",MB_OK);
    return 1;
  }

  CloseHandle(pif.hProcess);   //Close handle to process
  CloseHandle(pif.hThread);    //Close handle to thread

  return 0;
}

#include <windows.h>  //You need shell32.lib for this one 

int main(void)
{
  char szPath[] = "C:\\WINDOWS\\system32\\Calc.exe";

  HINSTANCE hRet = ShellExecute(
        HWND_DESKTOP, //Parent window
        "open",       //Operation to perform
        szPath,       //Path to program
        NULL,         //Parameters
        NULL,         //Default directory
        SW_SHOW);     //How to open

  /*
  The function returns a HINSTANCE (not really useful in this case)
  So therefore, to test its result, we cast it to a LONG.
  Any value over 32 represents success!
  */

  if((LONG)hRet <= 32)
  {
    MessageBox(HWND_DESKTOP,"Unable to start program","",MB_OK);
    return 1;
  }

  return 0;
}