您如何在C语言中解释这个类似于函数的宏`slice`的输出？

Question

#include <stdio.h>

#define slice(bare_string,start_index) #bare_string+start_index
#define arcane_slice(bare_string,start_index) "ARCANE" #bare_string+start_index

int main(){
    printf("slice(FIRSTA,0)==> `%s`\n",slice(FIRSTA,0));
    printf("slice(SECOND,2)==> `%s`\n",slice(SECOND,2));
    printf("slice(THIRDA,5)==> `%s`\n",slice(THIRDA,5));
    printf("slice(FOURTH,6)==> `%s`\n",slice(FOURTH,6));
    printf("slice(FIFTHA,7)==> `%s`\n",slice(FIFTHA,7));
    printf("arcane_slice(FIRSTA,0)==> `%s`\n",arcane_slice(FIRST,0));
    printf("arcane_slice(SECOND,2)==> `%s`\n",arcane_slice(SECOND,2));
    printf("arcane_slice(THIRDA,5)==> `%s`\n",arcane_slice(THIRDA,5));
    printf("arcane_slice(FOURTH,6)==> `%s`\n",arcane_slice(FOURTH,6));
    printf("arcane_slice(FIFTHA,7)==> `%s`\n",arcane_slice(FIFTHA,7));
    return 0;
}

OUTPUT:

slice(FIRSTA,0)==> `FIRSTA`
slice(SECOND,2)==> `COND`
slice(THIRDA,5)==> `A`
slice(FOURTH,6)==> ``
slice(FIFTHA,7)==> `slice(FIFTHA,7)==> `%s`
`
arcane_slice(FIRSTA,0)==> `ARCANEFIRST`
arcane_slice(SECOND,2)==> `CANESECOND`
arcane_slice(THIRDA,5)==> `ETHIRDA`
arcane_slice(FOURTH,6)==> `FOURTH`
arcane_slice(FIFTHA,7)==> `IFTHA`

I have the above C code that I need help on. I am getting weird behaviour from
the function-like macro slice that is supposed to 'slice' from a passed index
to the end of the string. It does not slice in the real sense but passes
a pointer from a certain point to printf which starts printing from that
address. I have managed to figure out that in arcane_slice the strings
are concatenated first then 'sliced'. I also have figured out that when start_index
is equal to 6 printf starts printing from the null byte and that is why
you get the 'empty' string. The strange part is when start_index is 7. It prints
the first argument to printf (interpolator string) concatendated with the passed bare string in both.
arcane_slice and slice (as shown in the 5th and 10th lines in the output)
Why is that so?
My wildest guess is that when the start_index exceeds the length of the strings,
the pointer points to the start of the data segment in the program's address space. But
then you could counter that with "why didn't it start printing from FIRSTA "

Answer 1

Not any "data segment", the stack. This is what I remember: when C calls a function it first puts data on stack, first variable arguments, then the format, all being the addresses to the memory sequentially allocated with your text. In that block of memory, the last argument (c-string) goes first, and the first goes last, thus:

Memory:

"FIFTHA\0slice(FIFTHA,7)==> `%s`\n\0"

Arguments:

<pointer-to-"FIFTHA"> <pointer-to-"slice...">

Since you overincrement the first one it skips the '\\0' character and points at the format as well.

Try to experiment with this with more placeholders, like

 printf("1: %s, 2: %s\n", slice(FIFTHA,7), slice(FIFTHA,6));

Answer 2

 slice(bare_string,start_index) #bare_string+start_index  

you are passing a string and bare_string stores the starting address of string which you have passed and then you returning changed pointer location which is bare_string+start_index

char str[6]="Hello";

char *ptr =str;

printf("%s\n",str);//prints hello

printf("%s\n",str+1);//prints ello
printf("%s\n",str+2);//prints llo
printf("%s\n",str+3);//prints lo
printf("%s\n",str+4);//prints o
printf("%s %c=%d  \n",str+5,*(str+5),*(str+5));//prints Null
printf("%s %c=%d  \n",str+6,*(str+6),*(str+6));//prints Null or may be Undefined behavior
printf("%s %c=%d  \n",str+7,*(str+7),*(str+7));//prints Null or may be Undefined behaviour

the same scenario is happing in your case.

Test Code:

#include<stdio.h>

main()
{
char str[6]="Hello";

char *ptr =str;

printf("%s\n",str);//prints hello

printf("%s\n",str+1);//prints ello
printf("%s\n",str+2);//prints llo
printf("%s\n",str+3);//prints lo
printf("%s\n",str+4);//prints o
printf("%s %c=%d  \n",str+5,*(str+5),*(str+5));//prints Null
printf("%s %c=%d  \n",str+6,*(str+6),*(str+6));//prints Null or may be Undefined behavior
printf("%s %c=%d  \n",str+7,*(str+7),*(str+7));//prints Null or may be Undefined behaviour

}

Answer 3

You have answered your question yourself. "FIFTHA"+7 gives you a pointer outside the string object, which is undefined behavior in C.

There's no easy way to get a more Python-like behavior for such "slices" in C. You could make it work for indexes up to a certain upper limit by adding a suffix to your string, full of zero bytes:

#define slice(bare_string,start_index) ((#bare_string "\0\0\0\0\0\0\0")+(start_index))

Also, when using macros, it's good practice (and avoids bugs too) to use parentheses excessively.

#define slice(bare_string,start_index) ((#bare_string)+(start_index))
#define arcane_slice(bare_string,start_index) (("ARCANE" #bare_string)+(start_index))