1

consider the following code:

t[7] = "Hellow\0";
s[3] = "Dad";
//now copy t to s using the following strcpy function:

void strcpy(char *s, char *t) {
    int i = 0;

    while ((s[i] = t[i]) != '\0')
        i++;
}

the above code is taken from "The C programming Language book". my question is - we are copying 7 bytes to what was declared as 3 bytes. how do I know that after copying, other data that was after s[] in the memory wasn't deleted?

and one more question please: char *s is identical to char* s?

Thank you !

Improve this question
3
  • Originally I mis-read this question. You can't have expression statements at global scope (such as t[7] = ) also your function parameters s and t mask the global variables s and t. What book did you get this from, certainly not K&R's "The C Programming Language". Commented Aug 14, 2010 at 10:35
  • Please make sure your code compiles before posting it here. Commented Aug 14, 2010 at 10:52
  • You are not copying anything - there is no call to the strcpy function. Also, the s and t in the function are supplied parameters and have absolutely nothing to do with the t and s declared above. Please provide the full code. Commented Aug 14, 2010 at 11:22

5 Answers 5

Reset to default
2

As you correctly point out, passing s[3] as the first argument is going to overwrite some memory that could well be used by something else. At best your program will crash right there and then; at worst, it will carry on running, damaged, and eventually end up corrupting something it was supposed to handle.

The intended way to do this in C is to never pass an array shorter than required.

By the way, it looks like you've swapped s and t; what was meant was probably this:

void strcpy(char *t, char *s) {
    int i = 0;

    while ((t[i] = s[i]) != '\0')
        i++;
}

You can now copy s[4] into t[7] using this amended strcpy routine:

char t[] = "Hellow";
char s[] = "Dad";

strcpy(t, s);

(edit: the length of s is now fixed)

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

Explicitly specifying the terminating '\0' leaves you with one more character than will fit in each buffer, as C strings are always automatically null-terminated.
2

About the first question.

If you're lucky your program will crash.

If you are not it will keep on running and overwrite memory areas that shouldn't be touched (as you don't know what's actually in there). This would be a hell to debug...

About the second question.

Both char* s and char *s do the same thing. It's just a matter of style.

That is, char* s could be interpreted as "s is of type char pointer" while char *s could be interpreted as "s is a pointer to a char". But really, syntactically it's the same.

Improve this answer

1 Comment

Except for local variable declarations, where "char* a, b;" has unexpected results.
1

That example does nothing, you're not invoking strcpy yet. But if you did this:

strcpy(s,t);

It would be wrong in several ways:

  • The string s is not null terminated. In C the only way strcpy can know where a string ends is by finding the '\0'. The function may think that s is infinite and it might corrupt your memory and make the program crash.
  • Even if was null terminated, as you said the size of s is only 3. Because of the same cause, strcpy would write memory beyond where s ends, with maybe catastrophic results.

The workaround for this in C is the function strncpy(dst, src, max) in which you specify the maximum number of chars to copy. Still beware that this function might generate a not null terminated string if src is shorter than max chars.

Improve this answer

1 Comment

Regarding bullet #1: He is copying from t to s so it doesn't matter if s is a ntbs or not. All it needs is a null terminator for t which is there.
1

I will assume that both s and t (above the function definition) are arrays of char.

how do I know that after copying, other data that was after s[] in the memory wasn't deleted?

No, this is worse, you are invoking undefined behavior and we know this because the standard says so. All you are allowed to do after the three elements in s is compare. Assignment is a strict no-no. Advance further, and you're not even allowed to compare.

and one more question please: char s is identical to char s?

In most cases it is a matter of style where you stick your asterix except if you are going to declare/define more than one, in which case you need to stick one to every variable you are going to name (as a pointer).

Improve this answer

Comments

-1

a string-literal "Hellow\0" is equal to "Hellow"

if you define

t[7] = "Hellow";
s[7] = "Dad";

your example is defined and crashes not.

Improve this answer

1 Comment

A string-literal "Foo" will have an internal representation {'F','o','o','\0'} but that's not the question anyway...

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.