第一週: 誠實面對自己

#include <stdio.h>
#include <string.h>
void foo(void)
{
    const char *p = "abc";
    char s[] = "efg";
    const char cS[] = "ijk";

    puts(p);
}

.LC0:
        .string "abc"
foo:
        pushq   %rbp
        movq    %rsp, %rbp
        subq    $16, %rsp
        movq    $.LC0, -8(%rbp)
        movl    $6776421, -12(%rbp)
        movl    $7039593, -16(%rbp)
        movq    -8(%rbp), %rax
        movq    %rax, %rdi
        call    puts
        nop
        leave
        ret

_foo_s_10000_41:
        .ds 4
_foo_cS_10000_41:
        .ds 4
_foo:
        ar7 = 0x07
        ar6 = 0x06
        ar5 = 0x05
        ar4 = 0x04
        ar3 = 0x03
        ar2 = 0x02
        ar1 = 0x01
        ar0 = 0x00
        mov     _foo_s_10000_41,#0x65
        mov     (_foo_s_10000_41 + 0x0001),#0x66
        mov     (_foo_s_10000_41 + 0x0002),#0x67
        mov     (_foo_s_10000_41 + 0x0003),#0x00
        mov     _foo_cS_10000_41,#0x69
        mov     (_foo_cS_10000_41 + 0x0001),#0x6a
        mov     (_foo_cS_10000_41 + 0x0002),#0x6b
        mov     (_foo_cS_10000_41 + 0x0003),#0x00
        mov     dptr,#___str_0
        mov     b, #0x80
        ljmp    _puts
___str_0:
        .ascii "abc"

const int a = 1; /*declare a as const int*/
const int *p = &a /*declare p as pointer to const int*/

#include <stdio.h>
#include <string.h>
const char a[] = "abc"; /*這個要宣告在所有function 的外面才會等效語法糖*/
void foo(void)
{
    const char *p = &a[0];
}
void bar(void)
{
    const char *p = "abc";
    puts(p);
}
void uwu(void)
{
    const char b[] = "abc"; /*declare b as array of const char, and "abc" is copied into the a array at compile time*/
    const char *p = &b[0];
}

    for(int i = 0 /*1*/, i < 1 /*2*/, i++ /*4*/)
        printf("%d\n",i); /*3*/

int FuncX(struct node *head, int *data) {
    struct node *node;
    for (node = head->next;     /*1. initialize node is head->next*/
         node && node != head;  /*(Verify that the node is not the head) and (Verify node is not null)*/
                                /*2. (Verify that the head->next is not the head) and (Verify head->next is not null)*/
        node = node->next)      /*4. head->next = head->next->next */
        data++;                 /*3. memory address plus one and throw away*/
    return node - head;         /*5. calcualte the memory address distance between the head->next and head*/
}

while (*candidate != target)
   candidate = &(*candidate)->next

if (!prev)
    list->head = target->next;
else
    prev->next = target->next;

void remove_list_node(List *list, Node *target)
{
    Node **candidate;
    Node *prev = NULL;
    Node *current = list->head;
    // Walk the list
    while (current != target) {
        prev = current;
        current = current->next;
    }
    // Remove the target by updating the head or the previous node.
    if (!prev)
        candidate = &list->head;
        candidate = target->next;
    else
        candidate = &prev->next;
        candidate = target->next;
}

void remove_list_node(List *list, Node *target)
{
    Node **candidate = &list->head;
    Node *prev = NULL;
    Node *current = *candidate;
    // Walk the list
    while (current != target) {
        prev = current;
        current = current->next;
    }
    // Remove the target by updating the head or the previous node.
    if (!prev)
        /* candidate = &list->head; */ /*因為重複所以可以刪除*/
        candidate = target->next;
    else
        candidate = &prev->next;
        candidate = target->next;
}

void remove_list_node(List *list, Node *target)
{
    Node **candidate = &list->head;
    Node *prev = NULL;
    // Walk the list
    while (*candidate != target) {
        prev = *candidate;
        candidate = &(*candidate)->next;
    }
    // Remove the target by updating the head or the previous node.
    if (!prev)
        candidate = target->next;
    else
        candidate = &prev->next;
        candidate = target->next;
}

void remove_list_node(List *list, Node *target)
{
    Node **candidate = &list->head;
    Node *prev = NULL;
    // Walk the list
    while (*candidate != target) {
        prev = *candidate;
        candidate = &(*candidate)->next;
    }
    // Remove the target by updating the head or the previous node.
    if (prev)
        candidate = &prev->next;
    candidate = target->next;
}

void remove_list_node(List *list, Node *target)
{
    Node **candidate = &list->head;
    Node *prev = NULL;
    while (*candidate != target) {
        prev = *candidate;
        candidate = &(*candidate)->next;
    }
    candidate = target->next;
}

void remove_list_node(List *list, Node *target)
{
    Node **candidate = &list->head;
    Node *prev = NULL;
    while (*candidate != target) {
        prev = *candidate; /*prev會變成前一位候選人=>A*/
        *candidate = &(*candidate)->next; /*候選人變成下一位候選人=>(B)*/
    }
    if (prev) /*prev 是(A)*/
        candidate = &prev->next; /*候選人會變成前一位候選人(A)的下一位(B)，就是現在這位，等於沒變*/
    candidate = target->next;
}

void remove_list_node(List *list, Node *target)
{
    Node **candidate = &list->head;
    while (*candidate != target) {
        *candidate = &(*candidate)->next; /*候選人變成下一位候選人*/
    }
    candidate = target->next;
}