Changing strings to upper within a double pointer array

Question

I need to convert arguments given at command line such as: $ myprogram hello world

and the words need to be printed in CAPS. I am able to to do everything except access the double pointer array to make the changes with toupper()

static char **duplicateArgs(int argc, char **argv)
{
    char **copy = malloc(argc * sizeof (*argv));
    if(copy == NULL){
        perror("malloc returned NULL");
        exit(1);
    }

    int i;
    for(i = 0; i<argc; i++){
         copy[i] = argv[i];   
    }
    char **temp;
    temp = &copy[1];
    *temp = toupper(copy[1]); 

    return copy;
}

Answer 1

*temp = toupper(copy[1]);

toupper converts a single character, if you want to convert an entire string:

char *temp = copy[1]; /* You don't need a double pointer */
size_t len = strlen(temp);

for (size_t i = 0; i < len; i++) {
    temp[i] = toupper(temp[i]); 
}

Answer 2

From the man page of toupper() the function prototype is

int toupper(int c);

In your code, the argument copy[1] is not an int value.

Instead what you want is to check each and every element, if they are in lower case, convert them to upper case. A pseudo-code will look like

for(i = 0; i<argc; i++){
         copy[i] = malloc(strlen(argv[i])+ 1);  //allocate memory 

for (j = 1; j < argc; j++)
  for (i = 0; i < strlen(argv[j]); i++)
  {
    if (islower(argv[j][i]))   //check if it is lower case
         copy[j-1][i] = toupper(argv[j][i]);
    else
         copy[j-1][i] = argv[j][i];          //do not convert
  }

Answer 3

I assume the argument that is passed into your function char **argv is passed directly from main, so it represents a pointer to the beginning of an array of pointers to each of the command line arguments.

argc represents the number of command line arguments.

Inside your function, you create a new buffer, and then copy the contents of argv into it. So you are creating a copy of the array of pointers to the command line arguments, NOT the command line argument strings themselves.

I am guessing you intended to copy the strings, rather than the pointers to the strings (what would be the point of that?). I suggest you look into the functions strdup and/or strncpy to copy the actual strings.

This also explains with the 'toupper' does not work as you expect - instead of passing a single character to it, you are passing a pointer to a null terminated string of characters.

Answer 4

You are running into an error using the toupper() function because you are trying to pass in a string instead of an individual letter. Here is an excerpt from the man page describing the function:

DESCRIPTION
     The toupper() function converts a lower-case letter to the corresponding
     upper-case letter.  The argument must be representable as an unsigned
     char or the value of EOF.

You have a pointer to a pointer which you could visulize as something like this. In C a string is just an array of chars so you need to dereference twice to get the data in the second level of arrays (the individual letter). Every time you add an * you can think of it as removing one layer of pointers. And you can think of the * operator as the inverse of the & operator.

This line is your problem line

temp = &copy[1];

try this instead

//This is a pointer to an individual string
char *temp = copy[1];
//Keep going while there are letters in the string
while(*temp != NULL) {
    //convert the letter
    toupper(*temp);
    //Advance the pointer a letter
    temp++;
}

Answer 5

Consider this example:

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

static char **duplicateArgs(int argc, char **argv)
{
    char **copy = NULL;
    // allocate memry for pointers to new lines
    copy = (char **)malloc(sizeof(char *) * argc);
    int line, chr;
    for(line = 0; line < argc; line++)
    {
        // allocate memory for new line
        copy[line] = (char *)malloc(sizeof(char) * (strlen(argv[line]) + 1));
        // copy with changes
        for(chr = 0; chr <= strlen(argv[line]); chr++)
        {
            copy[line][chr] = toupper(argv[line][chr]);
        }
    }
    return copy;
}

int main(int argc, char * argv[])
{
    char ** strs;
    int i;
    strs = duplicateArgs(argc, argv);
    for(i = 0; i < argc; i++)
    {
        printf("%s\n", strs[i]);
    }
    return 0;
}

EDIT:

Also you can make a decision about using argv[0] (name of executable file) and change a code if you need. Also checking of malloc result can be added, and other improvements... if you need :-)