C passing char array to function, compute with another char array and copy

The most glaring things wrong in this code are:

1. Implicit declaration of myfunction as int myfunction();
2. Incorrect const-ness of your pointers.
3. No return value provided for main()

Implicit declaration of myfunction as int myfunction();

This is easy enough to solve, and your compiler should be barking loudly at you when this happens. As a legacy feature of C, when a function call is encountered where no formal declaration, either by prototype or definition, is known, the function is assumed to return int and accept a variable number of parameters. Therefore in main() your call is assumed to be to a function that looks like this:

int myfunction();

Later when the real myfunction is encountered, at a minimum your compiler should scream at you with warning about how the declaration doesn't match the expected type (because by this time it thinks it is int myfunction()). Even then, however, the call should still go through, but it is terrible practice to rely on this. Properly prototype your functions before use.

Incorrect data types for all your pointers.

The string literal in your function is not bound to local array space. It is a read-only data buffer sitting in a read-only segment somewhere in your program's data blocks. The correct declaration is this:

const char *test = "mytest";

but that has the ripple effect of requiring changes to the rest of this code, which you'll see in a moment.

No return value provided for main()

Be definitive in your conclusion of main(). Apparently C99 allows you to skip this and implementation is supposed to return 0 for you. Don't give them that joy; seize it yourself.

Addressing all of the above...

#include <stdio.h>

void myfunction(const char** in);

int main()
{
    const char *result = NULL;
    myfunction(&result);
    printf("in main() %p : %s\n", result, result);
    return 0;
}

void myfunction(const char** in) 
{
    const char* test = "mytest";
    printf("in myfunction() %p : %s\n", test, test);
    *in = test;
}

Output (varies by implementation)

in main() 0x8048580 : mytest
in myfunction() 0x8048580 : mytest

See it live.

It looks good to me. May I suggest giving it a prototype or moving your myfunc() definition before main(). Also assigning a value to result when it is declared. That will give you a better idea of what is going on if the function is not doing what you expect.

For some reason, the other answers just pointed out technical detail that's wrong, but failed to notice what is really wrong: You are returning the address of an array on the stack. But when the function returns, accessing that array becomes undefined behavior. Other code may freely overwrite the memory, leaving the worst possible garbage in it, or, conversely, writing to the memory behind the returned pointer may trash any vitally important variable of some other, entirely unconnected parts of the code.

If you want to return a pointer, you must either return a pointer to a static object, or you must return a pointer to something on the heap. Here is the static case:

char* foo() {
    static char staticArray[1024];
    return staticArray;
}

Using static here guarantees that the memory reserved for staticArray[] will remain reserved for it throughout the execution of your program. There are, however, three downsides of this:

1. the array size is fixed at compile time

2. this is generally not multithreading safe since all threads will use the same globally allocated memory

3. you generally cannot expect the data behind the returned pointer to remain intact across a function call. Consider this code:

   void bar() {
       char* temp = foo();
       temp[0] = 7;
   }
   
   void baz() {
       char* temp = foo();
       temp[0] = 3;
       bar();
       //now temp[0] is 7 !
   }
   

This might be desirable in some rare cases, however, in most it's not.

So, if you want to be able to freely use the memory behind the returned pointer, you have to malloc() memory for it (and free() it afterwards, of course). Like this:

char* foo(int size) {
    return malloc(size);
}

void baz() {
    char* sevenBytes = foo(7);
    //Do something with seven bytes
    free(sevenBytes);
}

void bar() {
    char* threeBytes = foo(3);
    threeBytes[0] = 3;
    baz();
    assert(threeBytes[0] == 3);    //baz() worked on it's own memory
    free(threeBytes);
}

In the case of string handling, there is a number of handy functions available in the POSIX-2008 standard that do the memory allocation for you, among them strdup() and asprintf(). Here are some usage examples:

int main() {
    char* hello = strdup("Hello");
    char* greeting;
    if(0 > asprintf(&greeting, "%s World!\nMemory for hello was allocated at %llx", hello, (long long)hello)) {
        //error handling
    }
    printf(greeting);
    free(hello);
    free(greeting);
}

This will print something like:

Hello World!
Memory for hello was allocated at c726de80