what't the reason when implicit declaration of function

Question

Why does the return value of the function change when the number of bytes of malloc is large?

func.c:

#include "func.h"

int *func()
{
    int *ptr = (int *)malloc(100000000);
    printf("ptr in func is %p \n", ptr);
    return ptr;
}

func.h:

#ifndef _FUNC_H
#define _FUNC_H
#include <stdio.h>
#include <stdlib.h>
//int *func();
#endif

main.c

#include <stdio.h>
#include "func.h"

int main(int argc, char** argv)
{
    int *ptr = func();
    printf("ptr is %p \n", ptr);
}

compilation and run:

gcc -g main.c func.c -o main

the compilation result is:

main.c: In function ‘main’:
main.c:7:13: warning: implicit declaration of function ‘func’; did you mean ‘putc’? [-Wimplicit-function-declaration]
  int* ptr = func();
             ^~~~
             putc
main.c:7:13: warning: initialization makes pointer from integer without a cast [-Wint-conversion]

run result:

ptr in func is 0x7f557ea88010
ptr is 0x7ea88010

Why does the function return the same value when the number of bytes of malloc is small?

func.c

#include "func.h"

int *func()
{
    int *ptr = (int *)malloc(100);
    ptrintf("ptr in func is %p \n", ptr);
    return ptr;
}

run result:

ptr in func is 0x17af2a0
ptr is 0x17af2a0

Can you tell me why? I want to know what exactly caused it?

Answer 1

You're obviously working on 64 bit system with sizeof(int *) == 8 and sizeof(int) == 4. Now when the function prototype is missing ("implicit declaration") the compiler assumes that func() returns int and so when you call int *ptr = func() only 4 bytes (sizeof(int)) of the return value are used, interpreted as int and cast back to int *. That results in the wrong ptr in the first example.

Int the second example, by chance the pointer value is smaller so it fits completely in 4 bytes and after being cast back, the result ist the same pointer again. Nevertheless it's Undefined Behaviour and you should really always treat the warning "implicit declaration" as an error and provide all necessary prototypes.

Answer 2

You must declare functions before you use them.

Corrected func.c

#include <stdio.h>   // put includes you use in the .c file
#include <stdlib.h>  // put includes you use in the .c file
#include "func.h"

int* func(void)  // put void, so the compiler knows there are no
                 // arguments
{
   int* ptr = malloc(100000000);   // remove the (int*) cast, it's
                                   // not wrong, but useless
   printf("ptr in func is %p \n", ptr);
   return ptr;
}

Corrected func.h:

#ifndef _FUNC_H
#define _FUNC_H
// remove this (not wrong but bad practice) #include <stdio.h>
// remove this (not wrong but bad practice) #include <stdlib.h>

int* func(void);   // uncomment this and put void, so the compiler 
                   // knows there are no arguments

#endif

Corrected main.c

#include <stdio.h>   // put includes you use in the .c file
#include "func.h"

int main(int argc, char** argv)
{
    int* ptr = func();
    printf("ptr is %p \n", ptr);
}

---

Following happens when you don't declare func prior to using it:

int* ptr = func();

As func() has not been declared, the compiler assumes (wrongly) that func returns an int (it actually returns a pointer to int). The function is called, the returned pointer in converted into an int possibly truncating the value from 64 bits to 32 bis (it depends on the platform).

If the returned address fits into 32 bits (which may be the case on certain platforms for small allocations), no truncation takes place.