问题[c](coding)

我有以下 C 程序：

__int64_t fib_tr_const (__int64_t n, __int64_t n_1, __int64_t n_2)
{
    if (n == 0x42 || n == 0x43 ) {
        return n_1 + n_2;
    }

    return 0x31 + fib_tr_const (n-1, n_2, n_1 + n_2);
}


void main (int argc, char ** argv)
{
    __int64_t n = atoi (argv[1]);
    // printf("fib(%ld) = %ld\n", n, fib(n));
    // printf("fib_tr(%ld) = %ld\n", n, fib_tr(n, 0, 1));
    __int64_t volatile result = 0x4567;
    printf ("11111\n");
    printf ("11111\n");
    result = fib_tr_const(n, 0x123, 0x234);
    printf ("22222\n");
    printf ("22222\n");
    printf("fib_tr_const(%ld) = %ld\n", n, result);
}

我用 建造了它-O2。

gcc tail_call.c -O2 -o tail_call_const_O2

我反汇编了二进制文件：

主要()：

00000000000010a0 <main>:
    10a0:   f3 0f 1e fa             endbr64 
    10a4:   41 54                   push   %r12
    10a6:   ba 0a 00 00 00          mov    $0xa,%edx
    10ab:   48 83 ec 10             sub    $0x10,%rsp
    10af:   48 8b 7e 08             mov    0x8(%rsi),%rdi
    10b3:   31 f6                   xor    %esi,%esi
    10b5:   e8 c6 ff ff ff          callq  1080 <strtol@plt>
    10ba:   48 8d 3d 43 0f 00 00    lea    0xf43(%rip),%rdi        # 2004 <_IO_stdin_used+0x4>
    10c1:   48 c7 44 24 08 67 45    movq   $0x4567,0x8(%rsp)
    10c8:   00 00 
    10ca:   4c 63 e0                movslq %eax,%r12
    10cd:   e8 9e ff ff ff          callq  1070 <puts@plt>
    10d2:   48 8d 3d 2b 0f 00 00    lea    0xf2b(%rip),%rdi        # 2004 <_IO_stdin_used+0x4>
    10d9:   e8 92 ff ff ff          callq  1070 <puts@plt>


------------------START-------------------

    10de:   49 8d 44 24 ff          lea    -0x1(%r12),%rax
    10e3:   48 83 f8 01             cmp    $0x1,%rax
    10e7:   76 75                   jbe    115e <main+0xbe>
    10e9:   4c 89 e0                mov    %r12,%rax
    10ec:   31 c9                   xor    %ecx,%ecx
    10ee:   ba 01 00 00 00          mov    $0x1,%edx
    10f3:   31 ff                   xor    %edi,%edi
    10f5:   eb 0c                   jmp    1103 <main+0x63>
    10f7:   66 0f 1f 84 00 00 00    nopw   0x0(%rax,%rax,1)
    10fe:   00 00 
    1100:   48 89 f2                mov    %rsi,%rdx
    1103:   48 8d 34 17             lea    (%rdi,%rdx,1),%rsi
    1107:   48 89 c7                mov    %rax,%rdi
    110a:   48 83 e8 01             sub    $0x1,%rax
    110e:   48 01 f9                add    %rdi,%rcx
    1111:   48 89 d7                mov    %rdx,%rdi
    1114:   48 83 f8 02             cmp    $0x2,%rax
    1118:   75 e6                   jne    1100 <main+0x60>
    111a:   48 01 f2                add    %rsi,%rdx
    111d:   48 01 d1                add    %rdx,%rcx
    1120:   48 8d 3d e3 0e 00 00    lea    0xee3(%rip),%rdi        # 200a <_IO_stdin_used+0xa>
    1127:   48 89 4c 24 08          mov    %rcx,0x8(%rsp)

------------------END-------------------


    112c:   e8 3f ff ff ff          callq  1070 <puts@plt>
    1131:   48 8d 3d d2 0e 00 00    lea    0xed2(%rip),%rdi        # 200a <_IO_stdin_used+0xa>
    1138:   e8 33 ff ff ff          callq  1070 <puts@plt>
    113d:   48 8b 4c 24 08          mov    0x8(%rsp),%rcx
    1142:   48 83 c4 10             add    $0x10,%rsp
    1146:   31 c0                   xor    %eax,%eax
    1148:   4c 89 e2                mov    %r12,%rdx
    114b:   48 8d 35 be 0e 00 00    lea    0xebe(%rip),%rsi        # 2010 <_IO_stdin_used+0x10>
    1152:   bf 01 00 00 00          mov    $0x1,%edi
    1157:   41 5c                   pop    %r12
    1159:   e9 32 ff ff ff          jmpq   1090 <__printf_chk@plt>
    115e:   ba 01 00 00 00          mov    $0x1,%edx
    1163:   31 c9                   xor    %ecx,%ecx
    1165:   eb b6                   jmp    111d <main+0x7d>
    1167:   66 0f 1f 84 00 00 00    nopw   0x0(%rax,%rax,1)
    116e:   00 00 

fib_tr_const()：

00000000000012e0 <fib_tr_const>:
    12e0:   f3 0f 1e fa             endbr64 
    12e4:   48 8d 47 be             lea    -0x42(%rdi),%rax
    12e8:   48 89 f9                mov    %rdi,%rcx
    12eb:   48 83 f8 01             cmp    $0x1,%rax
    12ef:   77 0a                   ja     12fb <fib_tr_const+0x1b>
    12f1:   eb 35                   jmp    1328 <fib_tr_const+0x48>
    12f3:   0f 1f 44 00 00          nopl   0x0(%rax,%rax,1)
    12f8:   48 89 c2                mov    %rax,%rdx
    12fb:   48 83 ef 01             sub    $0x1,%rdi
    12ff:   48 8d 04 16             lea    (%rsi,%rdx,1),%rax
    1303:   48 89 d6                mov    %rdx,%rsi
    1306:   48 83 ff 43             cmp    $0x43,%rdi
    130a:   75 ec                   jne    12f8 <fib_tr_const+0x18>
    130c:   48 8d 34 49             lea    (%rcx,%rcx,2),%rsi
    1310:   48 01 c2                add    %rax,%rdx
    1313:   48 c1 e6 04             shl    $0x4,%rsi
    1317:   48 8d 8c 31 2d f3 ff    lea    -0xcd3(%rcx,%rsi,1),%rcx
    131e:   ff 
    131f:   48 8d 04 0a             lea    (%rdx,%rcx,1),%rax
    1323:   c3                      retq   
    1324:   0f 1f 40 00             nopl   0x0(%rax)
    1328:   48 89 d0                mov    %rdx,%rax
    132b:   48 89 f2                mov    %rsi,%rdx
    132e:   31 c9                   xor    %ecx,%ecx
    1330:   48 01 c2                add    %rax,%rdx
    1333:   48 8d 04 0a             lea    (%rdx,%rcx,1),%rax
    1337:   c3                      retq   
    1338:   0f 1f 84 00 00 00 00    nopl   0x0(%rax,%rax,1)
    133f:   00 

有了地标printf ("11111\n");和printf ("22222\n");，因此在汇编中。我相信和puts之间的部分应该是调用的地方。STARTENDmain()fib_tr_const()

我没有看到任何call从jmpmain() 分支到 fib_tr_const() 的指令。那么这个函数是如何调用的呢？

我将标记点之间的汇编与 fib_tr_const() 的汇编进行了比较。asm 代码看起来很相似。看来 fib_tr_const() 函数是内联的。

另一个问题出现了——如果函数是内联的，为什么代码仍然存在于最终的二进制文件中？如果删除它，可以节省空间，那么为什么不发生这种情况呢？

场景如下，一台服务器使用 select() 处理多个客户端，其中几个 fd 非常活跃（其中几个 fd 上有大量数据），而其他 fd 则处于正常活跃状态。那么其他 fd 是否会饿死，因为 select 将忙于为非常活跃的 fd 提供服务？

我正在尝试使用 realloc 为我的动态数组添加内存。但在我的代码中，realloc 为数组添加了额外的内存。假设我最初想创建包含 5 个项目的数组，然后想添加 3 个项目，因此数组的总长度应该是 8。但它显示的长度超过了分配的长度，为什么？我还附上了输出。

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int n, i, added_data;
    int *data;

    printf("Enter the total number of elements: ");
    scanf("%d", &n);

    
    data = (int *)calloc(n, sizeof(int));
    if (data == NULL)
    {
        printf("Error!!! memory not allocated.");
        exit(0);
    }

    
    for (i = 0; i < n; i++)
    {
        printf("Enter number %d: ", i + 1);
        scanf("%d", data + i);
    }

    printf("Enter number of elements to add: ");
    scanf("%d", &added_data);

    if(added_data > 0)
    {
        data = realloc(data, added_data * sizeof(int));

        for (i=0; i < added_data; i++)
        {
            //n++;
            printf("Enter number %d: ", i + 1);
            scanf("%d", data + n);
            n++;
        }
    }

    int new_length = n + added_data;
    printf("\nnew length of array: %d", new_length);
    printf("\n");

    for(i=0;i<new_length;i++)
    {
        printf("%d\n", data[i]);
    }

    printf("\n");

    free(data);

    return 0;
}

输出：：

Enter the total number of elements: 5
Enter number 1: 1
Enter number 2: 2
Enter number 3: 3
Enter number 4: 4
Enter number 5: 5
Enter number of elements to add: 3
Enter number 1: 55
Enter number 2: 99
Enter number 3: 88

new length of array: 11
1
2
3
4
5
55
99
88
10053856
0
10027344

我有这个代码：

#include<stdio.h>
#include<stdlib.h>

typedef struct{
    int data;
    struct node *next;
} NODE;

NODE *head = NULL;

void display_ll(NODE *head){
    if (head == NULL){
        printf("\nList is empty");
    } else{
        for(NODE *curr=head; curr!=NULL; curr=curr->next){
            printf("%d ->", curr->data);
        }
        printf("\b\b  ");
    }
}

int main(void){
    NODE *temp = (NODE *)malloc(sizeof(NODE));
    temp->data = 5;
    temp->next = NULL;
    head = temp;
    display_ll(head);
    return 0;
}

在第 15 行，即我在循环curr=curr->next中执行的操作for，如果使用 clang 进行编译，则会收到警告，如果使用 gcc 进行编译，则会收到错误：

1. 铛：

   warning: incompatible pointer types assigning to 'NODE *' from 'struct node *' [-Wincompatible-pointer-types]
   

2. 海湾合作委员会：

   error: assignment to ‘NODE *’ from incompatible pointer type ‘struct node *’ [-Wincompatible-pointer-types]`
   

我想到了一种解决方法，我们将结构写为，typedef struct node {...} NODE;这样就可以了。但我想知道是否有任何方法可以解决这个问题，而无需重新定义这个结构。

我是 Linux 网络方面的新手。我特别查看了一些 ICMP 协议的示例，特别是查看了 ping 请求和回复。通常都是从打开原始套接字开始的

int sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);

然后就有了类似的东西（粗略的代码）

while (1) {
   sendto(sockfd, ...);
   usleep(CERTAIN_TIME);
   recvfrom(sockfd, ...);
   // then the reply is elaborated
}

我想知道是否也可以打开其中两个原始套接字：一个仅用于sendto，另一个用于recvfrom并由两个不同的线程使用它们：

// initialization
int sendsock = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
int recvsock = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);

然后

// thread 1
while (1) {
   sendto(sendsock, ...);
   usleep(CERTAIN_TIME);
}

// thread 2
while (1) {
   recvfrom(recvsock, ...);
   usleeep(CERTAIN_TIME);
}

它安全吗？

假设我有一个结构

struct s
{
    int a;
}

以及像这样的主要功能

int main()
{
    struct s s1 = {.a = 10};
    
    struct s *sptr = &s1;
    
    sptr->a--;
    printf("%d\n", sptr->a);
    
    s1.a = 10;
    
    --sptr->a;
    printf("%d\n", sptr->a);
    
    return 0;
}

输出 ：

9
9

按照运算符优先级，->具有--相同的优先级和左->右结合性。

如果是sptr->a--，我可以理解sptr->a是先完成然后再--应用。

但在 的情况下--sptr->a，--应首先应用于sptr。这可能会导致未定义的行为，但应该是这样。为什么这仍然与 一样有效sptr->a--？

我刚刚开始阅读 K&R 书。它介绍了一个 getchar() putchar() 循环程序，用于将字符从输入复制到输出，直到到达 EOF。

main()
{
    int c;

    while ((c = getchar()) != EOF)
        putchar(c);
}

我尝试将其改为无限循环，看看当我尝试打印 EOF 时会发生什么。以下是代码：

#include <stdio.h>

int main() {
    int c;
    while(1) {
        c = getchar();
        if (c == EOF) {
            printf("%d", c);    // Since you cannot really use putchar() for EOF as it is -1
            // break;
        } else {
            putchar(c);
        }
    }
    putchar('\n');
    return 0;
}

示例输出：

./a.out 
a
a
-1
-1
df
df
-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1

我本来希望它打印 -1 然后等待下一个输入，但我发现它只是一直打印 -1。

如果我在打印 EOF 一次后添加一行来中断循环，它会打印 -1 一次然后退出程序，这是可以理解的。

但我不明白为什么没有 break 语句它只是继续循环并打印 -1。

起初我以为它以某种方式使用输出 -1 作为下一个循环的输入（实际上是接下来的 2 个循环，因为 -1 是 2 个独立的字符“-”和“1”），但如果是这种情况，为什么当我放入任何其他字符（如“a”）时没有看到这种无限循环行为，根据我之前的逻辑，这应该连续打印“a”。

有人能帮忙解释一下发生了什么事吗？

我目前正在研究加密，我想出了反转字节半字节的方法（例如0xF5=> 0x5F）。我想出了这个解决方案：

byte >> 4 | (byte & 0x0F) << 4

我在网上找到的其他解决方案是类似的，但是通过屏蔽字节的左半字节添加了一个额外的操作数：

(byte & 0xF0) >> 4 | (byte & 0x0F) << 4

用二进制表示的话，第二个解决方案如下：

# Extract the right nibble of a byte and shift to the left
[0xF5] 1111 0101       # Original Value
[0x0F] 0000 1111 &     # Mask Right Nibble
[0x05] 0000 0101 =     # Extracted Right Nibble
[0x50] 1010 0000 << 4  # Shift Four Bits to the Left

# Extract the left nibble of a byte and shift to the right
[0xF5] 1111 0101       # Original Value
[0xF0] 1111 0000 &     # Mask Left Nibble
[0xF0] 1111 0000 =     # Extracted Left Nibble
[0x0F] 0000 1111 >> 4  # Shift Four Bits to the Right

# Combine the shifted nibbles together
[0x05] 0000 1111       # Left Nibble Shifted to the Right
[0xF0] 0101 0000 |     # Right Nibble Shifted to the Left
[0xF5] 0101 1111 =     # New Value

如果我错了，请纠正我，但如果您处理的数据类型大于一个字节并且仅关注最低有效字节，则第二种解决方案很有用。因此，如果您在不屏蔽的情况下进行移位，则高阶字节的位将传播到左半字节中。因此，在这种情况下，屏蔽左半字节是必要的。

# Bits shift into the least significant byte without masking
[0x0AF5] 0000 1010 1111 0101
[0x00AF] 0000 0000 1010 1111 >> 4

另一方面，如果您真正使用一个字节，那么屏蔽左半字节是否是多余的，因为在右移四位后左半字节位将被清零？

[0xF5] 1111 0101
[0x0F] 0000 1111 >> 4

也许还有其他我不知道的原因需要屏蔽左半字节。例如，其他系统在需要第二种解决方案时可能会有不同的表现。

我的想法是否正确，或者我是否应该考虑一些事情？

以下是进一步说明的示例代码：

typedef uint8_t byte;

static inline
byte swap_nibbles(byte bits) {
    return bits >> 4 | (bits & 0x0F) << 4;
}

我知道编译器可以将多个非易失性加载合并为单个加载。这是否意味着内存映射函数可以创建未定义的行为？

例如：

int k = *p;

unmapFile(fm, fileHandle1);//the unmapped memory includes the address pointed to by p

//p is no longer valid, pointing to a virtual address that is unmapped

mapFile(fm, fileHanlde2);//p now points to an address somewhere in a different file

int j = *p;

//use k and j here

p 的两个取消引用是否可以合并为一个，从而导致代码行为不可预测？

另外，我知道文件映射函数不允许您指定映射的起始地址（至少在 posix 和 windows 中），但这是我能想到的最简单的假设。这种范例确实有用例。

我正在尝试用 C 正确处理用户输入，特别是从用户那里读取文件路径时。

然而，我有一些担忧：

1. 我如何重构此代码来处理动态内存分配。
2. 当长度未知时，应如何正确处理用户输入的动态内存分配？
3. 接受用户输入的文件路径最安全的方法是什么？

我当前的代码：

#include <stdio.h>

int main() {
    char filePath[1024];

    printf("Please provide file to encrypt (File Path): ");
    scanf("%1024s", filePath); // Is this safe?

    printf("You entered: %s\n", filePath);
    return 0;
}

我在微软的网站上找到一个来源，建议我为%s格式说明符指定一个宽度scanf（例如，%1024s而不是%s），但它仍然是固定大小，我希望它动态分配。