I can't return a character string in C

Question

Hello ;

I have a problem with my program, which needs to calculate the @host network of an IP address. The steps of the program are :

1. Add the mask and the ip in a "network" variable in binary (in int)
2. Convert the "reseau" variable in decimal (in char[])
3. Return the "network" variable in main

Anyway, I'm at step 1. And to see that everything works, I am trying to return the string "reseau" which contains the binary addition.

Problem: I can't do it unfortunately. It's giving me the following error code:

returning 'char *' from a function with return type 'char' makes integer from without a cast [-Wint-conversion] 33. return reseau;

I suspect it's because you can't return a char tab like that (from my research) but I can't figure it out.

Code :

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

char calcul(char* octet, char* masque);

void main(){
    char octetB[]="11000000101010000000000100000111";
    char masqueB[]="11111111111111111111111100000000";

    printf("octetB : %s\n", octetB);
    printf("octetB 3e valeur : %c\n", octetB[2]);

    printf("Adresse réseau : %s\n", calcul(octetB, masqueB));
}

char calcul(char* octet, char* masque){
    int i;
    char reseau[100];

    printf("\n");
    printf("octet dans calcul : %s\n", octet);
    printf("masque dans calcul : %s\n", masque);

    for(i=0; i<32; i++){
        if((octet[i]='1') && (masque[i]='1')){
            reseau[i]='1';
        } else {
            reseau[i]='0';
        }
        printf("nombre %d : %d\n", i, reseau[i]);
    }
    return reseau;
}

So I would love to have some help to know where I went wrong? In order to understand. Thanks :D

Answer 1

The solution using malloc() has the disadvantage that memory is allocated but the responsibility for freeing that memory is not clear. The caller need not even know the memory is dynamically allocated (why should it?), and fail to free it resulting in a memory leak. Normally the responsibility for freeing an allocation should be clear. It is not a good solution in this case.

A simple (but still imperfect) solution is to statically allocate the string being returned:

const char* calcul( const char* octet, const char* masque )
{
    static char reseau[33] = "" ;

    ...

    return reseau;
}

This has a problem however of not being reentrant (an issue in multi-threading or recursive code) and caller still needs to understand restrictions and issues related to use of a static buffer. The pointer returned is the same for all callers, such that the string will be modified if the function is called subsequently. A caller may copy the string, or ensure that it has completed all processing on it before calling the function again. It is probably better that dynamic memory allocation, but still requires the caller to have knowledge of the internal memory management to uses it appropriately.

Another disadvantage of the solution is returning a const no write access can be performed outside the function, so if that is necessary the caller would have to copy the string to a local buffer. Returning a non-const would be a really bad idea - you would be modifying the "hidden" buffer inside the function.

The more usual and more flexible idiom is for the caller to "own" the buffer and pass it to the function for it to be filled. That way the memory may be an array, or dynamically allocated according to the needs of the caller. In this case you would also pass the length of the array, so that the function can avoid overrunning the caller's buffer:

const char* calcul( const char* octet, const char* masque, 
                    char* reseau, size_t reseau_len )
{
    ...

    for( i = 0; 
         octet[i] != 0 && masque[i] != 0 && i < reseau_len; 
         i++)
    {
        ...
    }

    return reseau;
}

So then the function might be called thus:

    char reseau_buf[sizeof(octetB)] ;
    printf( "Adresse réseau : %s\n", 
            calcul( octetB, masqueB, 
                    reseau_buf, sizeof(reseau_buf) ) ) ;

Note that this last version also makes no assumptions about the length of either masque or octet - the loop stops at the shorter of all the inputs. If they differ that is a bug at the caller, the function implementation will fail "gracefully" and deterministically and thus be easier to debug.

---

Aside on interpretation of the assignment

None of the above seems to correctly address the assignment, which you appear to have misunderstood. I would expect a solution to look something like:

#include <stdio.h>
#include <stdint.h>

uint32_t subnet( uint32_t ip, uint32_t mask, char* subnet_str ) ;

int main()
{
    uint32_t ip = 0xC0A80001 ;      // 192.168.0.1
    uint32_t netmask = 0xFFFFFF00 ; // 255.255.255.0

    char ipstring[] = "000.000.000.000" ;
    printf( "0x%08X : ", subnet(ip, netmask, ipstring) ) ;
    printf( "%s\n", ipstring ) ;
}

uint32_t subnet( uint32_t ip, uint32_t mask, char* subnet_str )
{
    // Step 1 : apply mask to get subnet
    uint32_t network = ...

    // Step to: convert network to "xxx.xxx.xxx.xxx" string form
    // in subnet_str
    ...

    // Step 3
    return network ;
}

With output:

0xC0A80000 : 192.168.1.0

Clearly help with any of that warrants a new question. But is is far simpler that the work you have already put in. Both step 1 and 2 can be implemented each as a single line of code.

Answer 2

The problem is that your function calcul() returns a character array or a pointer to a character (char*) although your function definition says the return type is char. This is why your getting the compile error.

But furthermore you can't return the array reseau. This variable is local and only available within your function. Outside of the function calcul() this character array isn't valid anymore.

And the next problem in your code is that reseau doesn't have a nul termination at the end. So your printf() will not work as you expected.

And finally I found another problem in your code. The statement octet[i]='1' is a assignment. In your case you would need a comparison. You will have to change it to octet[i]=='1' (with double equal signs).

Answer 3

UP :

I have taken into account your comments and explanations. And now that it works (with the malloc system).

Thanks for your comments.

Here is the updated code for those who will come across the topic :

char* calcul(char* octet, char* masque){
    int i;
    char reseau[100];

    printf("\n");
    printf("octet dans calcul : %s\n", octet);
    printf("masque dans calcul : %s\n", masque);

    for(i=0; i<32; i++){
        if((octet[i]=='1') && (masque[i]=='1')){
            reseau[i]='1';
        } else {
            reseau[i]='0';
        }
        printf("nombre %d : %d\n", i, reseau[i]);
    }
    char* result = malloc(strlen(reseau)+1);
    strcpy(result, reseau);
    return result;
}

Answer 4

Your code doesn't compile because you return char at the calcul() function and returning a character array. If you want to return reseau character array you can do it using pointer. See the difference with the code below with your code to see how to implement it.

You also have some logical problem in your code, like there are no endline in reseau array, which result in printing garbage values after your desire string. and you use one equal = insteed of double equal == to compare equal in your code.

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

const char* calcul(char* octet, char* masque);

int main(){
    char octetB[]="11000000101010000000000100000111";
    char masqueB[]="11111111111111111111111100000000";

    printf("octetB : %s\n", octetB);
    printf("octetB 3e valeur : %c\n", octetB[2]);

    printf("Adresse réseau : %s\n", calcul(octetB, masqueB));
}

const char* calcul(char* octet, char* masque){
    int i;
    char *reseau = malloc(100);
    printf("\n");
    printf("octet dans calcul : %s\n", octet);
    printf("masque dans calcul : %s\n", masque);

    for(i=0; i<32; i++){
        if((octet[i]=='1') && (masque[i]=='1')){//use double equal to compare
            reseau[i]='1';
        } else {
            reseau[i]='0';
        }
        printf("nombre %d : %c\n", i, reseau[i]);
    }
    reseau[i]= '\0';//add endline
    return reseau;
}