C++ copying char* using pointers

Question

I am trying to grasp pointers and I have this simple code for which I need some explanation.

I need to copy one char array to another. In my main function I have this code:

const int MAX_SIZE = 100;

char x[MAX_SIZE] = "1234565";
char* y = new char[MAX_SIZE];

copyArray(x, y);    
std::cout << y;

delete [] y;

Now comes the question, how does this code (which works jut fine):

while ((*dest = *source) != '\0')
{
    dest += 1;
    source += 1;
}

Differ from this (gives strange characters at the end):

while (*source != '\0')
{
    *dest = *source;

    dest += 1;
    source += 1;
}

Looking at this it seems those two functions are pretty similar. It makes sense that we are copying until we reach a null-terminator in the source string, right (2nd function)?

But it's not working correctly - I get some strange characters at the end of the copied array. However, the first function works just fine.

void copyArray(const char* source, char* dest);

while ((*dest = *source) != '\0') guarantees that the necessary terminating '\0' character will be copied before the loop ends. Also see idownvotedbecau.se/nodebugging — user0042
– user0042, Commented Nov 21, 2017 at 22:41
You mean in the second example it will break the loop when it encounters '\0' meaning that it won't terminate the string? — user5446899
– user5446899, Commented Nov 21, 2017 at 22:43
@daavid245 Detail: The while (*source != '\0') loop does not "won't terminate the string". It won't terminate the character array. A character array is not a string until it has a null character. — chux
– chux, Commented Nov 21, 2017 at 22:47

user0042 · Accepted Answer · 2017-11-21 23:04:10Z

1

The form

while ((*dest = *source) != '\0')
{
    dest += 1;
    source += 1;
}

guarantees that the assignment of the character to copy ((*dest = *source)) is applied before testing the condition if the terminating '\0' character is reached is evaluated to false.

The second version doesn't copy the terminating '\0' character, because the loop ends before the

*dest = *source;

statement is ever reached.

answered Nov 21, 2017 at 23:04

user0042

8,0483 gold badges27 silver badges41 bronze badges

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

Comments

Sirmyself · Accepted Answer · 2018-01-25 20:00:59Z

1

(*dest = *source) is an evaluated expression just like the 1+1 part of int i = 1+1; so, after it is evaluated, the value is usable in an other expression

The difference is that in ((*dest = *source) != '\0'), the value of *source is assigned to *dest, then the whole expression is evaluated ( expression has the same value than *source ) while the value pointed by *source is only used to evaluate *source != '\0', but never assigned during the evaluation of that statement.

EDIT

user0042 brings a realy acute observation : by doing so, the following code

while ((*dest = *source) != '\0')
{
    dest += 1;
    source += 1;
}

ensures that the final char of the array has a value of '\0'

edited Jan 25, 2018 at 20:00

answered Nov 21, 2017 at 22:58

Sirmyself

1,5841 gold badge16 silver badges33 bronze badges

Comments

Raindrop7 · Accepted Answer · 2017-11-21 23:17:28Z

0

In the example you incrementing the addresses of x, y thus until the last character they point to Null-terminator so you have to declare a temporary variables to hold the first address:

char* x = "1234565";
char* y = new char[MAX_SIZE];

// Temporary pointers to hold the first element's address
char* tmp1 = x;
char* tmp2 = y;

while( (*y = *x) != '\0'){
    x += 1; // X no longer points to the first element
    y += 1; // Y no longer points to the first element
}

std::cout << tmp2;

You can use a do while loop instead of while:

char* x = "1234565";
const int size = strlen(x);
char* y = new char[size];

char* tmp1 = x;
char* tmp2 = y;

do{
    *y = *x;
    x += 1;
    y += 1;
}while( *(x - 1) != '\0');

// Now no need for adding a null-terminator it is already added in the loop
//  tmp2[size] = '\0';

std::cout << tmp2;

Because Assigning the values before incrementing so the last character \0 will break the loop before added to the destination pointer y. Thus I made the loop breaks not on n = '\0' but on n - 1 = '\0' to ensure that it is added to y.

edited Nov 21, 2017 at 23:17

answered Nov 21, 2017 at 23:02

Raindrop7

3,9113 gold badges19 silver badges27 bronze badges

1 Comment

Sirmyself Over a year ago

he increments x and y in both examples

Collectives™ on Stack Overflow

C++ copying char* using pointers

3 Answers 3

Comments

Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related