C++初识——基础语法大全

// test.cpp
#include<iostream>
using namespace std

int main()
{
    cout<< "Hello world" <<endl;
    return 0;
}

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

int rand = 0; // err

//编译器查找确认的默认规则是，先局部查找，找不到在去全局查找
//因为，在头文件stdlib.h中包含了rand 函数，这时我们创建一个全局变量rand就会出现命名冲突

int main()
{
    printf("%p\n", rand);
    return 0;
}

#include<iostream>
using namespace std

// 1. 正常命名空间的定义

namespace A
{
 // 命名空间中可以定义变量/函数/类型 
     int rand = 10;
     int Add(int left, int right)
     {
         return left + right;
     }

     struct Node
     {
         struct Node* next;
         int val;
     };
}

int a = 0;

int main()
{
    int a = 1;
 // :: 叫域限定作用符，:: 左边不写默认全局
    printf("%d\n",::a);
    printf("%d\n",a);
 // 这⾥默认是访问的是全局的rand函数指针 
     printf("%p\n", rand);
 // 这⾥指定bit命名空间中的rand 
     printf("%d\n", A::rand);
 // 调用命名空间A中的Add函数
     printf("%d\n",A::Add(1,2));
     return 0;
}

// 2. 命名空间的嵌套调用

namespace Student
{
	namespace A
	{
		int age = 20;
		
        int Add(int left, int right)
         {
             return left + right;
         }
	}

	namespace D
	{
		int age = 18;
		int number = 123;
	}
}

int a = 1;

int main()
{
    // 编译器默认查找规则不会再命名空间内查找，先在局部查找，在全局，找不到就会报错
	int a = 0;

	printf("%d ", a);
	printf("%d ", Student::A::Add(1,2));
	printf("%d ", Student::D::number);

	return 0;
}

// Stack.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

namespace ST
{
	typedef int STDataType;
	typedef struct Stack
	{
		STDataType* a;
		int top;
		int capacity;
	}ST;
	void Init(ST* ps, int n);
	void Destroy(ST* ps);

	void Push(ST* ps, STDataType x);
	void Pop(ST* ps);

}

// Stack.cpp
#include"Stack.h"
namespace ST
{
	void Init(ST* ps, int n)
	{
		assert(ps);
		ps->a = (STDataType*)malloc(n * sizeof(STDataType));
		ps->top = 0;
		ps->capacity = n;
	}
	// 入栈-栈顶
	void Push(ST* ps, STDataType x)
	{
		assert(ps);
		// 栈满，扩容
		if (ps->top == ps->capacity)
		{
			printf("\n");
			int newcapacity = ps->capacity == 0 ? 4 : ps->capacity* 2;
			STDataType* tmp = (STDataType*)realloc(ps->a,
				newcapacity * sizeof(STDataType));
			if (tmp == NULL)
			{
				perror("realloc fail");
				return;
			}
			ps->a = tmp;
			ps->capacity = newcapacity;
		}
		ps->a[ps->top] = x;
		ps->top++;
	}
}

// Queue.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

namespace Queue
{
	typedef int QDataType;
	typedef struct QueueNode
	{
		int val;
		struct QueueNode* next;
	}QNode;
	typedef struct Queue
	{
		QNode* phead;
		QNode* ptail;
		int size;
	}Queue;
	void Init(Queue* pq);
	void Destroy(Queue* pq);
	// ⼊队列 
	void Push(Queue* pq, QDataType x);
	// 出队列 
	void Pop(Queue* pq);
}

// Queue.cpp
#include"Queue.h"

namespace Queue
{
	//初始化
	void Init(Queue* pq)
	{
		assert(pq);
		pq->phead = NULL;
		pq->ptail = NULL;
	}


	//入队——队尾入
	void Push(Queue* pq, QDataType x)
	{
		assert(pq);
		//创建值为x的节点
		QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
		if (newnode == NULL)
		{
			perror("malloc fail!");
			exit(1);
		}
		newnode->val = x;
		newnode->next = NULL;

		//队列为空
		if (pq->phead == NULL)
		{
			pq->phead = pq->ptail = newnode;
		}
		else {
			pq->ptail->next = newnode;
			pq->ptail = pq->ptail->next;
		}
	}

}

// test.cpp

#include"Stack.h"
#include"Queue.h"

int main()
{
    ST::ST st;
    // 在Stack.h和Queue.h中，定义了同名函数Init，Push等，但是它们在不同的命名空间，所以调用时不会产生冲突
    ST::Init(&st);    
    ST::Push(&st,1);
    ST::Push(&st,2);
    ST::Push(&st,1);

    Queue::Queue q;
    Queue::Init(&q);
    Queue::push(&q,1);
    Queue::push(&q,2);
    Queue::push(&q,3);

    return 0;
}

#include<stdio.h>

namespace student
{
    int age;
}

// 编译查找时，编译器会先在局部查找，再在全局查找，不会在命名空间内查找
int main()
{
    // 编译报错：未声明的标识符 
     printf("%d\n", age);
     return 0;
}

// 指定命名空间访问

#include<iostream>

namespace student
{
    int age;
    int number;
}

using student::age; // 指定将命名空间中的某个成员展开
// 切记不要定义与展开的成员同名的变量
int age=0; // err

int main()
{

     printf("%d\n", a);
     // C++标准库都放在一个叫std的命名空间中，因此我们想要调用库中成员时，也要将要使用的成员展开
     std::cout<< age <<<<endl;
    
     return 0;
}

// 将命名空间中的所有成员展开

#include<iostream>
#include<algorithm>
usinig namespace std; // 将std命名空间中的所有成员展开，日常练习可以，项目不要这样
// C++标准库都放在一个叫std的命名空间中，因此我们想要调用库中的函数时，要先将他展开

int main()
{
	int i = 0;
	double b = 1.2;
	//先从局部查找，在从全局查找，如果都没找到，再从展开的std中查找
	cout << i << " " << b << std::endl;


	int arr[] = { 2,5,2,7 };
	sort(arr, arr + 3); // 库中的排序函数

	return 0;
}

#include<iostream>

int main()
{
	int i = 0;
	i << 5; // 左移操作符
	double b = 1.2;

    // vs编译器中，iostream头文件间接包含了stdio.h，其他编译器可能会报错
    scanf("%d，%lf", &a, &b);
    printf("%d %lf\n", a, b);


	//自动识别类型
	std::cout << i<<'\n'<<"\n"; // 这两个用来换行都可以，不会刷新缓冲区
	std::cout << "hello world"<<std::endl; // end line
	std::cout << i << " " << b << std::endl; // 用这个换行会刷新缓冲区

    //自动识别类型
	std::cin >> i >> b;
	std::cout << i << " " << b << std::endl;

	//类，复杂类型，IO流支持复杂类型的输入输出

	return 0;
}

int main()
{
	// 在io需求比较高的地方，如部分大量输入的的竞赛中，加上以下三行代码
	// 可以提高C++ IO效率
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);

	return 0;
}

// 全缺省参数
int func1(int x = 1, int y = 2)
{
	return x + y;
}

// 半缺省参数
// 给缺省值时，必须从右向左依次给，不能跳跃
int func2(int x, int y = 2, int z = 3)
{
	return x + y + z;
}

int main()
{
	// 带有全缺省参数的函数调用时，不给实参则使用缺省值
	int a = func1(); // 3
	// 带有全缺省参数的函数调用时，从左到右依次给实参，使用指定的实参
	int b = func1(10); // 12

	// 带有半缺省参数的函数调用时，没缺省值的形参，必须传实参
	int c = func2(100); // 105
	// 有缺省值的，可以不给，亦可以从左到右依次给实参
	int d = func2(100, 200); // 303

	cout << a << " " << b << " " << c << " " << d << endl;

	return 0;
}

// 有缺省参数的函数，不能声明和定义同时给缺省值，必须在声明时给缺省值

// Stack.h
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

namespace ST
{
	typedef int STDataType;
	typedef struct Stack
	{
		STDataType* a;
		int top;
		int capacity;
	}ST;

    // 函数声明时可以使用缺省参数
	void Init(ST* ps, int n = 100);
	void Push(ST* ps, STDataType x);
}

// Stack.cpp
#include"Stack.h"
namespace ST
{
    // 函数定义时，不能有缺省参数
	void Init(ST* ps, int n)
	{
		assert(ps);
		ps->a = (STDataType*)malloc(n * sizeof(STDataType));
		ps->top = 0;
		ps->capacity = n;
	}
	// 入栈-栈顶
	void Push(ST* ps, STDataType x)
	{
		assert(ps);
		// 栈满，扩容
		if (ps->top == ps->capacity)
		{
            // ...
		}
        // ...
	}
}

// test.cpp
#include"Stack.h"

int main()
{
    ST::ST st;
    // 已知要插入的数据的个数时，可以给定缺省值，这时不用扩容了
    ST::Init(&st);

    return 0;
}

void func();
void func(int a);

void func(int a);
void func(double b);

void func(int a, double b);
void func(double a, int b);

// 不构成重载
int func(int a);
double func(int b);

// 不构成重载
void func(int a, int b);
void func(int c, int d);

// 不构成重载
// 这两个函数对于调用者来说，参数类型都是 int
// 对于按值传递的参数，const 只表示在函数内部不能修改 data 的副本，它不改变传递给函数的参数类型
void func(int data);
void func(const int data);

// 不构成重载
// 当调用函数时，如果不传实参，编译器无法确认我们要调用那个函数
int func();
int func(int a = 1, int b = 2);

#incldue<iostream>
using namespace std;

int main()
{
	int a = 1;
	int& x = a;
	x = 100;

	cout << a << endl; // 100
    cout << a << endl; // 100

    // a和x的地址相同
	cout << &a << endl; 
	cout << &x << endl; 

	return 0;
}

#incldue<iostream>
using namespace std;

int main()
{
	int a = 1;
	
	int& x = a;
	int& y = x;
	int& z = a;

    // 任何一个值的改动都会影响其他的值
	cout << a << endl; // 1
	cout << x << endl; // 1
	cout << y << endl; // 1
	cout << z << endl; // 1

    // 地址都相同
	cout << &a << endl;
	cout << &x << endl;
	cout << &y << endl;
	cout << &z << endl;

	return 0;
}

// 引用传参

#include<iostream>
using namespace std;

// Swap函数构成了函数重载
void Swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;;
	*y = tmp;
}

// 形参是实参的别名，形参改变，实参就改变
void Swap(int& ra, int& rb)
{
	int tmp = ra;
	ra = rb;
	rb = tmp;
}

int main()
{
	int a = 1;
	int b = 2;

	Swap(&a, &b);
	cout << a << " " << b << endl; // 2 1

	Swap(a, b);
	cout << a << " " << b << endl; // 1 2

	return 0;
}

// 结构体的引用
// 以顺序表为例

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

namespace SLT
{
	typedef struct SeqList {
		int* a;
		int size;// 有效数据个数
		int capacity;
	}SLT;

	// 初始化
	void Init(SLT& p, int n = 4);
}

// SeqList.cpp
#include"Seqlist.h"

namespace SLT
{
	// 初始化
	void Init(SLT& p, int n)
	{
		p.a = (int*)malloc(sizeof(int) * n);
		p.size = p.capacity = 0;
	}
}

// test.cpp

#include"Seqlist.h"

int main()
{
	SLT::SLT s1;
    // 原本应该传指针，因为要改变形参的值
    // 这里运用引用传参，形参是实参的别名，形参的改变也会影响实参，比指针更好用
	SLT::Init(s1); 

	return 0;
}

// 指针定义别名

//Swap函数构成了重载
void Swap(int** ppa, int** ppb)
{
	int* tmp = *ppa;
	*ppa = *ppb;
	*ppb = tmp;
}

void Swap(int*& rpa, int*& rpb)
{
	int* tmp = rpa;
	rpa = rpb;
	rpb = tmp;
}

int main()
{
	int a = 1;
	int b = 2;

	int* pa = &a;
	int* pb = &b;

	Swap(&pa, &pb);
	cout << pa << pb << endl;

	Swap(pa, pb);
	cout << pa << pb << endl;

	return 0;
}

// 指针定义别名的应用
// 以单链表为例

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

namespace SL
{
	typedef struct SListNode {
		int val;
		struct SListNode* next;
	}SLNode;

	// 尾插
// 如果链表为空，那么尾插时就会插入头节点，头节点初始化时被定义为空，要改变头节点就是要改变形参
// 那么按照指针的知识，我们应该传二级指针，有了引用之后，我们可以直接传一级指针的引用，更加便捷
	// 尾插——引用法
    void PushBack(SLNode*& phead, int x);
    // 尾插——指针法
    void PushBack(SLNode** pphead, int x);
}

// SList.cpp
namespace SL
{
	// 尾插——引用法
	void PushBack(SLNode*& phead, int x)
	{
		SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
		// 链表为空
		if (phead == NULL)
		{
			phead = newnode;
		}
		// 找尾节点，链接
		// ...
	}
    // 尾插——指针法
	//void PushBack(SLNode** pphead, int x)
	//{
	//	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	//	// 链表为空
	//	if (*pphead == NULL)
	//	{
	//		*pphead = newnode;
	//	}
	//	// 找尾节点，链接
	//	// ...
	//}
}

// test.cpp
#include"SList.h"

int main()
{
	SL::SLNode* plist = NULL;
    // 尾插——引法
	SL::PushBack(plist, 1);
	SL::PushBack(plist, 2);
	SL::PushBack(plist, 3);
    // 尾插——链接法
    SL::PushBack(&plist, 1);
	SL::PushBack(&plist, 2);
	SL::PushBack(&plist, 3);

	return 0;
}

// 用typedef再简化

// SList.h
namespace SL
{
	typedef struct SListNode {
		int val;
		struct SListNode* next;
	}SLNode,*PNode;
    // 上面等价于下面
	// typedef struct SListNode SLNode;
	// typedef struct SListNode* PNode;
	
	// 尾插
	void PushBack(PNode& pphead, int x);
}

// SList.cpp
#include"SList.h"

namespace SL
{
	// 尾插
	void PushBack(PNode& phead, int x)
	{
		PNode newnode = (PNode)malloc(sizeof(SLNode));
		// 链表为空
		if (phead == NULL)
		{
			phead = newnode;
		}
		// 找尾节点，链接
		// ...
	}
}

// test.cpp
#include"SList.h"

int main()
{
	SL::SLNode* plist = NULL;
	SL::PushBack(plist, 1);
	SL::PushBack(plist, 2);
	SL::PushBack(plist, 3);

	return 0;
}

#include<iostream>
using namespace std;

// 传引用返回的错误场景
int& func1()
{
  //局部变量作返回值是不能用引用返回
	int ret = 0;
	//...
	return ret; //本质相当于返回ret的别名，但是ret的栈帧在函数结束时就已经还给操作系统了
}

// 传值返回
int func2()
{
	int y = 123;
	//...
	return y;
}

int main()
{
	int&x = func1(); // x是func1()的别名，func1()返回的又是ret的别名，所以x是ret别名的别名，也就是ret的别名
	cout << x << endl; //0 函数结束后，函数栈帧会销毁，但这里的销毁并不是将数据破坏，而是将内存空间还给了操作系统，空间的内容没有被销毁
	// 这时，如果我们再去通过引用来访问这块空间，可能是0也可能是随机值
	func2(); // 在func2()中局部变量y被创建，并赋值为123。这个y很可能就存放在了之前ret所在的位置
	cout << x << endl; //123 

	return 0;
}

// 跟踪main函数来梳理一下过程

int main()
{
	// 1. 调用func1()
	//    a. func1()的栈帧创建，ret=0。
	//    b. func1()返回ret的引用（即ret的内存地址）。
	//    c. func1()执行完毕，其栈帧被销毁，ret的内存空间被释放。
	// 2. 绑定引用
	//    d. 引用x成功绑定到了那个刚刚被释放的内存地址上。
	int& x = func1(); 

	// 3. 第一次访问悬挂引用
	//    e. cout << x << endl;
	//    f. 此时，虽然ret的内存空间已被释放，但操作系统还没有来得及用新的数据覆盖它。
	//    g. 因此，当我们通过x访问这块内存时，很可能还能读到旧的值，也就是0。
	//    h. 注意：这完全是“未定义行为” (Undefined Behavior)。标准C++没有规定这里应该输出什么，它可能是0，也可能是任何随机值。
	cout << x << endl; // 可能输出 0

	// 4. 调用func2()
	//    i. func2()被调用，它需要自己的栈帧。
	//    j. 由于func1()的栈帧已经释放，操作系统很可能将同一块内存分配给func2()使用。
	//    k. 在func2()中，局部变量y被创建，并赋值为123。这个y很可能就存放在了之前ret所在的位置。
	func2(); 

	// 5. 第二次访问悬挂引用
	//    l. cout << x << endl;
	//    m. 现在，x引用的那块内存空间里存放的已经不是0了，而是func2()中的y的值123。
	//    n. 所以，这次输出123。
	cout << x << endl; // 在VS编译器上输出 123，不同编译器可能不同 

	return 0;
}

int& func1()
{
	static int ret = 0;
	//出了作用域这个返回对象还在，才能用引用返回
	//...
	return ret; //出了函数之后，ret还在，才能用引用返回
}

int func2()
{
	int y = 123;
	//...
	return y;
}

int main()
{
	int& x = func1();
	cout << x << endl;//0
	func2();
	cout << x << endl;//0

	return 0;
}

int main()
{
	const int a = 0; // a只可读
	// 不能权限放大，a自己都不能改变，b是a的别名，却可读可写，这时错误的
	//int& b = a; // err
	
	// 不是权限放大，是拷贝赋值，开辟了一块新的空间赋值给e，e的读写不会影响a
	int e = a;
	
	const int& b = a; // true 

	int c = 0; // c类型是int,可读可写
	//可以权限缩小
	const int& d = c; // d是c的别名，只可读不可写，这时可以的

	//权限的缩小和放大，const 指针和引用
	const int* p1 = &a;
	// 不能权限放大
	//int* p2 = p1; // err
	const int* p2 = p1; // true

	//可以权限缩小
	int* p3 = &e;
	const int* p4 = p3;


	return 0;
}

int main()
{
    int a = 1;
    const int& ra = a; // 权限缩小

    return 0;    
}

int main()
{
    const int c = 1;
    const int& rc = c; // 必须加const

    return 0;    
}

int main()
{
	const int& a = 100; // 只读访问，不能修改，必须加const
	//当你写下 const int& a = 100; 时，编译器实际做了以下事情：
	//1、创建一个临时的 int 对象，并将其值初始化为 100。
	//2、将 a 这个引用绑定到这个刚刚创建的临时对象上。
	//3、因为 a 是一个 const 引用，编译器启动了 “生命周期延长” 规则。现在，这个临时对象的生命周期不再是当前行，而是被延长到了 a 所在的作用域结束。

	// int& a = 100; // err
	// a = 200; // err
	// 为什么？
	// 因为100是数学意义上的，如果不加const，意味着你可以改变它在数学上的含义，这是不可能的
		
    //100 是一个字面量，你不能修改数学意义上的数字 100。我们修改的只是那个临时创建用来存储值 100 的对象
	//但这个临时对象在 int& a = 100; 这行代码执行完毕后就会立刻被销毁。
	//那么 a 就变成了一个悬垂引用（Dangling Reference），指向一个已经不存在的内存地址。
	//后续任何通过 a 的操作都会导致未定义行为（Undefined Behavior），这通常是程序崩溃的根源。

	return 0;
}

// 类型转换底层机制
int main()
{
	int i = 1;
	// 隐式类型转换
	double d = i; // i不是直接给d的，i是先把自己的结构转换成浮点型，然后拷贝给一个临时变量，然后临时变量再给d，临时变量具有常性
	// 显式类型转换
	int p = (int)&i; // 这种也会产生一个临时变量，i会将自身结构转换为int类型拷贝到临时变量中，临时变量具有常性（可以理解为被const修饰）

	const double& rd = i; // 不加const错误的核心原因是权限的放大
	// 因为i会先转换为浮点型结构，拷贝到临时变量中，而临时变量有具有常性，所以要加const
	const int& rp = (int)&i; // 不加const错误的核心原因是权限的放大
	// i会先将类型转换为整型，然后拷贝到临时变量中，临时变量在赋值给rp,又因为临时变量具有常性，所以
    
    // 当 const int& ref_d = d; 执行时：
    系统会创建一个临时的 int 对象。
    将 d 的值（3.14）进行类型转换，截断为 int 值 3，并赋给这个临时对象。
    ref_d 引用的就是这个临时的 int 对象。

	return 0;
}

// 类型转换时用引用（取别名），要加const
int main()
{
    double i = 3.14;
    const int& ri = i; // 不加const错误的核心原因是权限的放大
	// 因为i会先转换为整型结构，拷贝到临时变量中，而临时变量有具有常性，所以要加const
    // 当 const int& ri = i;  执行时：
    // 1、系统会创建一个临时的 int 对象。
    // 2、将 d 的值（3.14）进行类型转换，截断为 int 值 3，并赋给这个临时对象。
    // 3、ri 引用的就是这个临时的 int 对象，临时对象具有常性不能修改，所以要加const

	const int& rp = (int)&i; // 不加const错误的核心原因是权限的放大（原因同上）
	// i会先将类型转换为整型，然后拷贝到临时变量中，临时变量具有常性，不可修改，rp引用的就是这个临时变量，所以要加const
    
}

void func1(int& x)
{}
// 如果引用传参，不是想让形参的改变影响实参，那么形参前面最好加上const
void func2(const int& y)
{}

int main()
{
	const int a = 1;
	const int& b = 2;

	//func1(a); // err // 权限放大
	func2(a); // true 
	//func1(b);// err // 权限放大
	func2(b); // true

	//func1(8); // err // 权限放大
	func2(8); // true

	double d = 3.14;
	//func1(d); //err 隐式类型转换，形参前必须加const
	func2(d); // true

	double* pd = &d;
	//func1((int)pd); // err 显示类型转换，形参前必须加const
	int z = (int)pd;
	func1(z); // true
	func2((int)pd); // true

	return 0;
}

int x = 10;
int &ref = x;  
// 底层类似于: int* const ref = &x;
// const 修饰的是指针 ref 本身，意味着指针 ref 的值（即它所存储的内存地址）是不可更改的。你不能让 ref 再指向其他变量。这对应了引用的 “绑定不可更改” 特性
// 指针 ref 被初始化为变量 x 的地址。这对应了引用的 “必须初始化” 特性。
ref = 20;      // 底层类似于: *ref = 20;

void example1() {
	int x = 10;
	int& r = x;
	r = 20;
}

//int x = 10;
//00007FF6E8E219AE  mov         dword ptr[x], 0Ah	 初始化x=10
//int& r = x;
//00007FF6E8E219B5  lea         rax, [x]			 将x的地址加载到rax
//00007FF6E8E219B9  mov         qword ptr[r], rax	 将地址存储到引用r中
//r = 20;
//00007FF6E8E219BD  mov         rax, qword ptr[r]	 从r中加载地址
//00007FF6E8E219C1  mov         dword ptr[rax], 14h  通过地址修改值为20

void example2() {
	int x = 10;
	int* r = &x;
	*r = 20;
}

//int x = 10;
//00007FF705652C6E  mov         dword ptr[x], 0Ah	 初始化x=10
//int* r = &x;
//00007FF705652C75  lea         rax, [x]			 将x的地址加载到rax
//00007FF705652C79  mov         qword ptr[r], rax	 将地址存储到引用r中
//* r = 20;
//00007FF705652C7D  mov         rax, qword ptr[r]	 从r中加载地址
//00007FF705652C81  mov         dword ptr[rax], 14h  通过地址修改值为20

#include<iostream>
using namespace std;
inline int Add(int x, int y)
{
     int ret = x + y;
     ret += 1;
     ret += 1;
     ret += 1;
     return ret;
}

int main()
{
     // 可以通过汇编观察程序是否展开 
     // 有call Add语句就是没有展开，没有就是展开了 
     int ret = Add(1, 2);
     cout << Add(1, 2) * 5 << endl;
     return 0;
}

// SeqList.h
#include<stdio.h>
typedef struct SeqList {
	int* arr;
	int size;
	int capacity;
}SL;

inline void SLInit(SL* plist, int n = 4)//缺省值为4，默认初始化时开辟4个元素大小的空间
{
    // ...
}
void SLPushBack(SL* plist, int x);

// SeqList.cpp
#include"SeqList.h"
void SLPushBack(SL* plist, int x)
{
    // ...
}

// test.cpp
#include"SeqList.h"

int main()
{
	SL s;
	//*内联函数必须直接在.h 文件中定义,这时可以直接展开
	//声明和定义分离，无法使用内联函数
	SLInit(&s); //这里的初始化函数是内联函数，在头文件中只定义了，但是没有实现，所以无法展开，只能call 函数地址，调用函数
	//编译的时候是找不到函数的地址的，在链接时去SeqList.cpp生成的.o 文件中找这个函数的地址
	//函数的地址是定义时生成的，函数第一句指令的地址就是函数的地址
	//编译器认为内联函数在调用的地方展开了，因此内联函数的地址不会放进符号表，编译器在链接时是找不到就会出错

	return 0;
}

#ifndef NULL
     #ifdef __cplusplus
         #define NULL 0
     #else
         #define NULL ((void *)0)
     #endif
#endif

#include <iostream>

void func(int x) {
    std::cout << "调用了 func(int)" << std::endl;
}

void func(char* p) {
    std::cout << "调用了 func(char*)" << std::endl;
}

int main() {
    foo(0);       // 调用 func(int)
    foo(NULL);    // 期望调用 func(char*)，但实际上可能调用 foo(int)，甚至无法编译
    return 0;
}

#include <iostream>

void func(int x) {
    std::cout << "调用了 func(int)" << std::endl;
}

void func(char* p) {
    std::cout << "调用了 func(char*)" << std::endl;
}

int main() {
    foo(0);       // 调用 func(int)
    foo(nullptr);    // 明确调用 foo(char*)
    return 0;
}