数据结构-语法规则

#include<iostream>
using namespace std;
void func1(int a){
    a=2;
}
void func2(int &b){
    b=2;
}
void func3(int *c){
    *c=2;
}
int main()
{
    int a=1,b=1,c=1;
    func1(a);
    func2(b);
    func3(&c);
    cout<<a<<" "<<b<<" "<<c<<" "<<endl;
    return 0;
}

char* p = "abc";                 // valid in C, invalid in C++
回顾：
以上如果是全局变量：p 存放在初始化数据段的rw段，"abc" 存放在代码段，p可以被重新赋值。static 修饰的函数内部变量如果未初始化，也在全局变量的bss段
如果是初始化列表{}里面的东西，有可能是放在数据只读RO段，也有可能放在代码段

void func4(const int &d){
    d=2;
}

int main(){
    int d=1;
    func4(d);
    func4(5);    // 放在func3中，这种用法是编译失败的
}

void func4(int &&d){
    d=2;
}

int main(){
    int d=1;
    func4(std::move(d));
}

// 递归删除不带头节点的单链表中所有值为x的节点。如果头节点就是要删除的元素，那么就需要加引用。

// 头指针LList指向头节点LNode，头节点可以被定义为链表上的任意节点。更新头节点要对LList* 型的结构体指针变量L进行修改，所以传值的时候形参必须使用引用，即：LNode *&L或者LList &L，两种方式等价，L的值可以被改变（LNode *L或者LList L，两种方式等价，L的值不可以被改变）。

// 可以自行编写程序自行测试：创建一个3节点的单链表，头指针指向第1个节点，使其成为3节点链表。再使头指针指向第2个节点，释放第1个节点，使其成为两个节点链表。

// C语言中不存在引用的问题，传过去的地址变量都能被改变。

#include <iostream>
using namespace std;

typedef struct LNode{
    int data;
    struct LNode *next;
}LNode,*LList;

void Del_X(LList &L,int x){    // 加引用&。注意这里是LList，相当于Node * &L
    LNode *p;
    if(L==NULL) return;
    if(L->data==x){
        p=L;
        L=L->next;                // 改变头节点，更新头节点L
        delete p;
        Del_X(L,x);
    }
    else
        Del_X(L->next,x);
}

void disL(LList L){
    LNode *p=L;
    while(p!=NULL){
        cout<<p->data<<endl;
        p=p->next;
    }
    cout<<"**"<<endl;
}

int main(){
    LList L=new LNode;      L->data=0;     // 这只是个地址变量，存放头节点地址，可以被改变
    LNode * L1=new LNode;   L->next=L1;    L1->data=1;
    LNode * L2=new LNode;   L1->next=L2;   L2->data=2;
    LNode * L3=new LNode;   L2->next=L3;   L3->data=3;
    LNode * L4=new LNode;   L3->next=L4;   L4->next=NULL;   L4->data=4;
    disL(L);
    Del_X(L,0);
    disL(L);
}

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

// C语言则不会出现这个问题

typedef struct Node{
    int data;
    struct Node *next;
}Node;

void Del_X(Node * L,int x){
    Node *p;
    if(L==NULL) return;
    if(L->data==x){
        p=L;
        L=L->next;
        free(p);
        Del_X(L,x);
    }
    else
        Del_X(L->next,x);
}

void disL(Node *L){
    Node *p=L;
    while(p!=NULL){
        printf("%d\n",p->data);
        p=p->next;
    }
    printf("**");
}

int main(){
    Node * L= (Node *)malloc(sizeof(Node));   L->data=0;
    Node * L1=(Node *)malloc(sizeof(Node));   L->next=L1;    L1->data=1;
    Node * L2=(Node *)malloc(sizeof(Node));   L1->next=L2;   L2->data=2;
    Node * L3=(Node *)malloc(sizeof(Node));   L2->next=L3;   L3->data=3;
    Node * L4=(Node *)malloc(sizeof(Node));   L3->next=L4;   L4->data=4;
    L4->next=NULL;
    disL(L);
    Del_X(L,2);
    disL(L);
}