How to return just the value of a string in C?

Question

How can I make a function in C that just returns the value of the string passed to it, for instance in the example given in main(), I would like to "normalize" the string "wACkY!" to just "Wacky!". I have managed to do this with a void function that directly modifies the string at its memory location, but what I want to do is not modify the string itself, but just return a modified version of it.

How can I do this?

printf("%s\n", normalize(string));

My normalize function

char *normalize(char *a) {
printf("%s\n", a);
int i = 0;
a[i] = toupper(a[i]);
for (i = 1; a[i] != '\0'; ++i) {
    a[i] = tolower(a[i]);
}
return a;
}

In main()

char *string = "wACkY!";
printf("%s\n", string);
printf("%s\n", normalize(string));

Answer 1

1. Create a new heap memory with the size of the string that you have passed, please consider addition +1 for '\0' character. Use malloc, or calloc.

2. Use memcpy or strncpy to write on the new heap memory.

3. Make changes to the new memory using whatever you have done with the normalize function.

4. And return the new char *

Answer 2

You can do this without using malloc(), and thus avoiding potential memory leaks, by employing VLAs, and changing the function prototype of normalize() to accept an additional argument that is an array for the new string.

In the program below, a character array, newstring[], is declared in main() after finding its size by finding the length of string using strlen() and adding space for the '\0' terminator. Note that the function normalize() modifies the character array newstring[] through the pointer to, so that after the function call the effects can be seen in newstring[] within main(). But newstring[] also returns a pointer to the first character in newstring[], allowing the string resulting from calling normalize() to be printed directly by printf().

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

char * normalize(char *to, char *from)
{
    strcpy(to, from);

    for (size_t i = 0; from[i] != '\0'; i++) {
        to[i] = tolower(from[i]);
    }

    to[0] = toupper(to[0]);

    return to;
}

int main(void)
{
    char *string = "wACkY!";
    size_t newstring_sz = strlen(string) + 1;
    char newstring[newstring_sz];

    printf("%s\n", string);    
    normalize(newstring, string);
    printf("%s\n", newstring);

    /* Alternatively */
    string = "wACkY!";
    printf("%s\n", string);    
    printf("%s\n", normalize(newstring, string));

    return 0;
}

Program output:

wACkY!
Wacky!
wACkY!
Wacky!

Answer 3

You need to write a function that either receives a buffer from the caller to place the modified string in, or allocates new memory for the modified string that it returns.

Although it wouldn't be difficult to provide you with this function, I feel you should do it yourself as a learning excercise. To allocate new memory for the string to return, look at malloc().

Answer 4

I think that a more flexible approach is when the function gets the target string as a parameter and performs copying of the source string.

Here is shown how it can look

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

char * copy_normalized( char *s1, const char *s2 )
{
    char *p = s1;

    while ( isspace( ( unsigned char )*s2 ) ) *p++ = *s2++;

    *p = toupper( ( unsigned char )*s2 );

    while ( *s2 ) *++p = tolower( ( unsigned char )*++s2 );

    return s1;
}   

int main( void ) 
{
    char s[] = "wACkY!";
    char t[sizeof( s )];

    puts( s );
    puts( copy_normalized( t, s ) );

    printf( "\n" );

    char *p = malloc( sizeof( s ) );

    puts( s );
    puts( copy_normalized( p, s ) );

    free( p );

    return 0;
}

The program output is

wACkY!
Wacky!

wACkY!
Wacky!

You can add a check that the character that should be converted to upper case is an alpha character.