Is there any benefit of using pointer arithmetic on character array in C?-CodePudding

I have a question regarding the operation on character array.

I was inspired by This answer here that discusses char* vs char[]. In this answer, it says considering a case where we want to cut off the first character of a word,

char* p = "hello";
p  ;

is a much faster operation, than if we declared using character array, and therefore had to index into every element.

char s[] = "hello";
s[0] = 'e';
s[1] = 'l';
s[2] = 'l';
s[3] = 'o';
s[4] = '/0';

But my question is, in the second case, cannot I just use another pointer that points to the start of s, i.e.

char* ptr = s;

and then treat it the same as char* p? Would it be as fast?

CodePudding user response：

You mean something like this?

char s[] = "Hello";
char *ptr = s 1;

Yes, you can do that, and it results in ptr pointing to the string "ello". It is just as fast; like the other example, it should be simple arithmetic and not require any copying of data.

I think it is a misconception to think of this as a "pointer versus array" issue. Pointers and arrays in C are inseparable. Both examples involve an array, and two different pointers into that array. In the first example, the array is created by the string literal "Hello" and doesn't have a name; the values of p before and after p both point into that array. In the second example, the array is named s, and the expression s decays into a pointer to the zeroth element of that array; s 1 is a pointer to the first element.

The main difference is that in the second example, the array can be modified, and may have a finite lifetime. So your program now has to manage issues of aliasing and ownership. Suppose one part of the code accesses the string through s, and another part accesses it through ptr. Are you prepared for the fact that if the first code modifies the string, the second code will see it change? Does your code correctly keep track of when the lifetime of s ends (e.g. the end of the block where it's defined), and does it make sure not to use ptr beyond that point?

By contrast, the string literal in the first example has static lifetime, and survives until the end of the program; so ptr = p 1 remains valid indefinitely. It also must not be modified at all, or undefined behavior results. So if your program is otherwise bug free, you don't have to worry about some other part of your code changing the string behind your back.

CodePudding user response：

The way I understand these things:

char *p = "hello";

Six bytes (including terminating '\0') are put in READ ONLY memory, and the address of the first byte is put into the variable p that has the datatype char *. Yes, the code can increment/decrement p to point further into the string.

char s[] = "hello";

Six bytes (including terminating '\0') are put in READ/WRITE memory, and referring to s means referring to the initial byte of the string. Yes, another pointer can be declared: char *p = s; And, yes, the code can manipulate the data stored in those six bytes.

char *p = &s[1]; // don't need to increment.

If you want to really play with things:

printf( "%.3s\n", &"Hi there"[3] );

will print "the". There is no name and no pointer, but there is an unnamed READONLY array that can be (carefully!) accessed.

Consider the following example that 'decorates' up to the 31 day of a month with the correct 'ordinal' suffix:

for( int DoM = 1; DoM <= 31; DoM   ) {
    int i = DoM;
    if( i > 20 ) i %= 10; // Change 21-99 to 1-10. Don't wanna think about 100 
    if( i >  3 ) i  =  0; // Every other one ends with "th"
                  //         0   1   2   3 
    printf( "%d%s\n", DoM, &"th\0st\0nd\0rd"[ i * 3 ] );
}