C / C++ / MFC

Write a program that will provide help with basic unix commands. The program should contain a loop that asks the user to input a unix command or enter quit to stop the program. Your program should recognize at least 6 of the basic unix commands like  pwd, etc.). Your program should print out the brief description of the command the user entered.  If the user enters a command that your program does not recognize, then print a message to that effect.
 
You must use the C++  string data type for your input variable.
 Hint: use the unix man command  to get the brief description for the commands you plan to put in your program. The brief description is the text that appears in the NAME section of the man page, after the command name followed by two hyphens (–). For example:

NAME
pwd -- return working  directory name 

struct sockaddr_ll sll;
struct ifreq ifr;

if ((sd = socket (PF_PACKET, SOCK_RAW, htons (0x2328))) < 0) {
    perror ("socket() failed to get socket descriptor for using ioctl() ");
    exit (EXIT_FAILURE);
}

// Use ioctl() to look up interface name and get its MAC address.
memset (&ifr, 0, sizeof (ifr));
sprintf (ifr.ifr_name, "eth1");

if (ioctl (sd, SIOCGIFINDEX, &ifr) < 0) {
    perror ("ioctl() failed");
    return (EXIT_FAILURE);
}

memset (&sll, 0, sizeof (sll));
int sll_len;
sll.sll_family  = AF_PACKET;
sll.sll_ifindex = ifr.ifr_ifindex;
sll_len         = sizeof(sll);

char buffer[1024];
recvfrom(sd, buffer, sizeof(buffer), 0, (struct sockaddr *)&sll, &sll_len);

struct args {
	int number;
	int result;
};

args user_arguments = { 10, 0 };
void fibonacci (void* arguments)
 {
 	args* local_args = (args*) arguments;
 	printf("local_args->number = %d\n", local_args->number);
     if (local_args->number <= 1) {
         local_args->result= 1;
         return;
     }
    int a = (local_args->number)-1;
    int b = (local_args->number)-2;
    local_args->result =fibonacci(&a) + fibonacci(&b)
     return local_args->result;

void WorkPackage(void*) {
 		createPackage(fibonacci, &user_arguments);
printf("Sum of fabonacci sequence is %d ", args->result) }

invalid operands of types ‘void’ and ‘void’ to binary ‘operator+’

/*  C++ program to rearrange positive and negative integers in alternate
    fashion while keeping the order of positive and negative numbers. */
#include <iostream>
#include <assert.h>
using namespace std;

void printArray(int arr[], int n);

// Utility function to right rotate all elements between [outofplace, cur]
void rightrotate(int arr[], int n, int outofplace, int cur)
{
    char tmp = arr[cur];
    for (int i = cur; i > outofplace; i--)
        arr[i] = arr[i-1];
    arr[outofplace] = tmp;
}

void rearrange(int arr[], int n)
{
    int outofplace = -1;

    for (int index = 0; index < n; index ++)
    {
        if (outofplace >= 0)
        {
            // find the item which must be moved into the out-of-place
            // entry if out-of-place entry is positive and current
            // entry is negative OR if out-of-place entry is negative
            // and current entry is negative then right rotate
            //
            // [...-3, -4, -5, 6...] -->   [...6, -3, -4, -5...]
            //      ^                          ^
            //      |                          |
            //     outofplace      -->      outofplace
            //
            if (((arr[index] >= 0) && (arr[outofplace] < 0))
                || ((arr[index] < 0) && (arr[outofplace] >= 0)))
            {
                rightrotate(arr, n, outofplace, index);
                printArray(arr, n);

                // the new out-of-place entry is now 2 steps ahead
                if (index - outofplace > 2)
                    outofplace = outofplace + 2;
                else
                    outofplace = -1;
            }
        }


        // if no entry has been flagged out-of-place
        if (outofplace == -1)
        {
            // check if current entry is out-of-place
            if (((arr[index] >= 0) && (!(index & 0x01)))      // what does (index & 0x01) means ??
                || ((arr[index] < 0) && (index & 0x01)))
            {
                outofplace = index;
            }
        }
    }
}

// A utility function to print an array 'arr[]' of size 'n'
void printArray(int arr[], int n)
{
    for (int i = 0; i < n; i++)
      cout << arr[i] << " ";
    cout << endl;
}

// Driver program to test abive function
int main()
{
    //int arr[n] = {-5, 3, 4, 5, -6, -2, 8, 9, -1, -4};
    //int arr[] = {-5, -3, -4, -5, -6, 2 , 8, 9, 1 , 4};
    //int arr[] = {5, 3, 4, 2, 1, -2 , -8, -9, -1 , -4};
    //int arr[] = {-5, 3, -4, -7, -1, -2 , -8, -9, 1 , -4};
    int arr[] = {-5, -2, 5, 2, 4, 7, 1, 8, 0, -8};
    int n = sizeof(arr)/sizeof(arr[0]);

    cout << "Given array is \n";
    printArray(arr, n);
    cout << "\n\n";

    rearrange(arr, n);

    cout << "\n\nRearranged array is \n";
    printArray(arr, n);

    return 0;
}

Quote:

// check if current entry is out-of-place
if (((arr[index] >= 0) && (!(index & 0x01))) // what does (index & 0x01) means ??
|| ((arr[index] < 0) && (index & 0x01)))
{
outofplace = index;
}