Strange behavior when returning "string" with C

Question

I'm a noob to C and I found my program acting very weird:

Here's the code:

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

char * p(char arg[] , char sym[] , int i , bool rv) {
    char head[i],w[i];
    strncpy(head,arg,i); head[i] = "\0";
    int l;
    for (l = 0 ; l <= (int)(strlen(sym) / i) ; l++) {
        strncpy(w,sym+l*i,i); w[i] = "\0";
        if (strcmp(head,w) == 0) {
            if (rv) { return head; } else {
                char v[strlen(arg) - i];
                strcpy(v,arg+i);
                v[strlen(arg)-i] = "\0";
                return v;
            };
        };
    };
    return arg;
}

int main() {
    printf(p("/parameter","+-\\/",1,false));
    getch();
}

The MAIN problem is that the returning value of the function is either a "string" of randomly generated codes or simply nothing.

It was expected to return / for return h; and parameter for return v;.

The other problem is that there is NO error found when I compile the program but bunch of warnings telling that the function returns address of local variable and assignment makes integer from pointer without a cast.

In the other hand, return arg; in very peaceful and doesn't gives out any error. (Try to change my codes in p("/parameter","+-\\/",1,false) if you don't believe it.) What have I done wrong?

---

Usage of the function:

p("argument_passed_to_check","symbols_accepted to_be_at_the_front","separate_for_each_i_characters","return_header_instead_of_parameter")

expected result:

p("-argue","/\\-",1,false) returns argue

p("/help","me",1,false) returns /help

p("/help","me",1,true) returns (null)

p("--parameter","--++",2,false) returns parameter

p("--parameter","--++",2,true) returns --

---

Summary for what am I asking help for:

• Except for return arg, other returning parts is weird: return head; is giving out random characters ; return v; returns nothing at all. How can I let them work as the expected results?

• Why are there those warnings?

Answer 1

1. Since head is defined as char head[i], its last element is head[i-1]. Attempting to access head[i] has behavior not defined by the C standard.

2. Since w is defined as char w[i], its last element is w[i-1]. Attempting to access w[i] has behavior not defined by the C standard.

3. Since v is defined as char v[strlen(arg) - i], its last element is v[strlen(arg) - i - 1]. Attempting to access v[strlen(arg) - 1] has behavior not defined by the C standard.

4. Since w is defined inside a brace-enclosed block of statements without extern or static, it is has automatic storage duration associated with the block, so it exists only while the function is block. When the return statement is executed, w ceases to exist (in C’s abstract machine). The statement return w; attempts to return a pointer to the first element of w (because, in this use, an array is automatically converted to a pointer to its first element). When this return statement is executed, the pointer becomes invalid.

5. Since v is defined inside a brace-enclosed block of statements without extern or static, it has automatic storage duration associated with the block, so v exists only while the statement is executing. When return v; is executed, execution of the block ends, and the returned pointer becomes invalid.

6. head[i] is a character, but "\0" is a string containing one character, so head[i] = "\0"; is an improper assignment. The string will be converted to a pointer to its first element, resulting in an attempt to assign a pointer to a char. This is a constraint violation, and your compiler should produce a warning for it. The same problem occurs in w[i] = "\0"; and v[strlen(arg)-i] = "\0";. The proper code would be head[i] = '\0'; (once the size of head is fixed to include an element head[i]).

Remedies include:

• Define each array to be large enough for all the elements to be written into it.
• To return strings created inside a function, either dynamically allocate space for them (as with malloc), create the strings inside arrays provided by the caller, or use arrays with static storage duration. If you use the first option, dynamically created arrays, you should make provisions for the space to be released (as by the caller passing them to free when done with them). You should avoid using arrays with static storage duration, as it has limited and troublesome use (such as the fact that only one such array exists for each definition, yet a function may be called multiple times by callers that each want their own separate data).