Thread: For Loop leaves C-String untouched

Trying to modify a string literal results in undefined behaviour. You could change the pointer to an array, but then when you return the array, it would be converted to a pointer to its first element... and then the caller would have a pointer to something that no longer exists. You could fix this by declaring the array static, but then the caller becomes responsible for copying over the string as needed.

Instead of returning a pointer, have a second pointer parameter that points to the first character of an array of char that will hold the result.

Originally Posted by SuchtyTV

Why does this result in undefined behaviour?

The simple answer is: because the C standard says so. The underlying reason is so that the string literal can be placed in memory that is not to be modified.

Originally Posted by SuchtyTV

I am not allowed to introduce a second parameter.

True, but you are not allowed to modify a string literal either. However, you are allowed to read and follow instructions: "either make the string static or allocate on the heap".

EDIT:
Oh wait, I see that they provided two examples. The second example is incorrect, and unfortunately you chose to follow it. Not your fault as it should have been:

Code:

char *str = malloc(12);

or something along those lines. For this particular case though, the static version is likely to be better since competitive programming like hacker rank may not care so much about maintainable code.

True, but you are not allowed to modify a string literal either. However, you are allowed to read and follow instructions: "either make the string static or allocate on the heap"

Didn't I?

Code:

char* military_time = "00:00:00";

I changed the code like this:

Code:

char* timeConversion(char* s) {    char* military_time = "00:00:00";
    strncpy(military_time, s,8);
    return military_time;

}

This still returns nothing.

No, you didn't. That declares a pointer that points to the first character of a string literal.

Yes, and the second example is wrong. Ignore it. I have an example of correctly allocating on the heap in my edit to my post #4.

Alright got it. I will try. Thank you.
Is allocating like in the incorrect example, a problem with their server? Is my code technically correct? What the reason why my code does not work?

Thank you.

Edit: Also this pointer can never be freed? Can it?

No, the instruction is correct. It is the second example that is wrong, i.e., it isn't actually an example of what you were instructed to do.

Your code is technically wrong because it attempts to modify a string literal. Doing that results in undefined behaviour. One symptom of undefined behaviour is that no matter how hard you try to modify it, the string remains unmodified. Another possible symptom of undefined behaviour is that your program crashes. Yet another possible symptom of undefined behaviour is that everything works, until the moment that you are demonstrating the program to important people, then Bad Things Happen. So, avoid undefined behaviour.

Code:

char* timeConversion(char* s) {
    char* military_time = malloc(sizeof("00:00:00"));
    strcpy(military_time, "00:00:00");

EDIT:
Actually, you don't need the strcpy. Aren't you already modifying in the loop in your original code? You don't seem to be using "00:00:00".

Yes, stop this "00:00:00" business and use s to compute how much space you need. For example:

Code:

char *military_time = malloc(strlen(s) + 1);

That said, doesn't "military time" take a specific maximum number of characters? You should be able to pre-determine that.

Okay. So you are creating a string which bigger than the actual string. I am unhappy, since we are wasting space here (I always need 8 characters + ''\0"). But it should work, since we all use more than GBs as Ram.
Then I need to take the first characters of s, modify them and put them into military_time. I am not allowed to modify directly. Is there a method for substitution?

EDIT: Yes, military string does need a constant amount of chars. However I need a way to copy from biggerString to smallerString with thereby setting '\0' at the end of the smaller string.