c++初学（上）

#include<stdio.h>
#include<stdlib.h>
int rand = 0;
int main()
{
	printf("%d", rand);
	return 0;
}

#include<stdio.h>
#include<stdlib.h>
namespace H
{
    int rand = 0;
}//命名空间的名字是由我们自己决定的，这里我就在H的命名空间中定义了一个rand
//如果我要在主函数中使用这个变量只用使用::这个符号就可以，
int main()
{
	printf("%p", rand);
	printf("%d", H::rand);
	//这样写就不会报错了。
	return 0;
}

#include<stdio.h>
namespace k
{
	int h = 30;
	struct people
	{
		int age = 18;
	};
}//在这个命名空间中我定义了一个名叫people的结构体
using k::people;//这就是部分展开，那么在使用people去定义新变量时就不需要使用::
//但是对于h仍旧要使用::去访问，
using namespace k;//这就是完全展开命名空间，如果这样写了，那么对于h也不需要使用::去访问了
//但是如果这个时候你又定义了一个全局变量h那么又会报错，原因和上面报错的原因是一样的。
int main()
{
	//然后在下面我需要多次使用这个结构体去创建多个变量那么每次都要使用::就会显得很麻烦，那就可以将k这个命名空间给展开
	//如果选择的是全部展开，那么命名空间中的所有变量都可以不使用::
	k::people lisi;
	k::people zhangsan;
	people kai;
	printf("%d\n", lisi.age);
	printf("%d\n", zhangsan.age);
	printf("%d\n", kai.age);
	return 0;
}

#include<iostream>
using std::cin;
using std::cout;
using std::endl;//endl为换行符作用与\n一样也是存在与std中的
//因为cin和cout是在命名空间std中的这里我就只将std部分展开了。
int main()
{
	int t;
	double s;
	char c;
	cin >> t >> s >> c;//并且输入也可以直接一并输入
	cout << t<<endl << s<<endl <<c <<endl;
	return 0;
}

#include<iostream>
using namespace std;//完全展开std命名空间
int add(int a = 0, int b = 0)
{
	return a + b;
}
int main()
{
	//很明显这个函数需要两个参数如果使用的是c，那么必须传入两个参数才能正常的运行代码，
	//但是在c++中可以使用缺省参数来达到只闯入一个或两个形参就能够正常运行
	cout<<add(1, 2)<<endl;//传入两个参数
	cout << add(1) << endl;//只传入个参数，并且实参输入默认为从左到右，即使在的前面加一个，也不能将1传给第二个参数，只能从左往右输入
	cout << add() << endl;//这里就直接使用默认的实参
	return 0;
}

#include<iostream>
using namespace std;//完全展开命名空间
int add(int a, int b)
{
	return a + b;
}
double add(double a, double b)
{
	return a + b;
}//如果在c中这里就会报错
//但是这里很明显传入的参数类型不一样，构成函数重载
//可以运行
int main()
{
	cout << add(1, 2) << endl;
	cout << add(1.5, 5.6) << endl;
	return 0;
}

void fun(int a, char b, double c)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}
void fun(int a, char b)
{
	cout << a << endl;
	cout << b << endl;
}//函数数量不同
void fun(char a, int b, double c)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}//函数顺序不同
//其余两种情况都构成函数重载
int main()
{
	fun(1, 'n', 2.5);
	fun(1, 'u');
	fun('b', 5, 3.3);
	return 0;
}

#include<iostream>
using namespace std;
int main()
{
	int i = 0;//这里我定义了一个整型变量i
	int& a = i;//这里我给这个整型变量起了一个别名a
	//对a进行++也会影响i
	a++;
	cout << i << endl;
	printf("%p\n", &i);//然后我打印了这两个变量的地址
	printf("%p\n", &a);
	return 0;
}

struct ListNode
{
	int val;
	struct ListNode* next;
};
//注意这不是完整的链表尾插代码
void PushBack(struct ListNode*& head, int val)
{
	struct ListNode* tmp = (struct ListNode*)malloc(sizeof(struct ListNode));//这里我简单创建一个临时空间用于尾插
	tmp->val = 0;
	if (head == NULL)//如果head为空那就要改变主函数中的struct ListNode*
		//如果这里的head为引用那就可以直接这样写，因为引用head也就表示了head和外面的struct ListNode是同一个指针变量
	{
		head = tmp;
	}
	else//那就找尾再改变尾的next指针即可
	{
		//在这一步骤不需要改变指针而是要在来链表上做出改变所以使用一级指针即可
	}
}
int main()
{
	struct ListNode* st;//假设创建一个链表st
	st = NULL;
	PushBack(st, 0);
	return 0;
}

//引用修改两数交换函数
void swap(int& p1, int& p2)
{
	int p3 = p1;
	p1 = p2;
	p2 = p3;
}
int main()
{
	int a = 50;
	int b = 100;
	swap(a, b);
	cout<<"a = " << a << endl;
	cout<<"b = " << b << endl;
	return 0;
}

int main()
{
	int a = 12;//这里我定义了一个变量
	int& b = a;//并且我为其取了一个别名为b
	int c = 30;//然后我又定义了一个c变量
	b = c;//那么这句代码是会让b成为c的别名吗？
	cout << "b = " << b << endl;
	cout << "a = " << a << endl;
	cout << "c = " << c << endl;
	//显然这里并没有让b成为c的别名，而是将c复制给了a
	//因为b仍然是a的别名，所以a被修改了
	//如果我让c+10但是a和b仍旧不会边
	c += 10;
	cout << "b = " << b << endl;
	cout << "a = " << a << endl;
	cout << "c = " << c << endl;

	return 0;
}

int main()
{
	const int a = 10;//假设这里我定义了一个变量a并让其拥有了常属性
	//那么引用时
	//int& b = a;//这样就会报错
	//在引用的时候也要加上const
	const int& b = a;//这样才能完成引用
	//而引用权限的缩小则是下面这种
	int c = 0;
	const int& f = c;//这样也就是权限的缩小
	return 0;
}

int& func()
{
	int a = 0;
	a++;
	return a;
}
int main()
{

	int c = func();//需要注意引用最后返回的是a所在的空间但是当出func函数之后这个空间就被还给系统了
	//所以这里c被赋值的到可能是1也可能是随机值，如果那片空间值没有被使用那么这里就还是1
	//如果被使用了返回的就是随机值。
	cout << c << endl;
	return 0;
}

int& func()
{

	int a = 0;
	a++;
	return a;
}
int main()
{
	int& c = func();//
	cout << c << endl;
  cout << c << endl;
	return 0;
}

int& func()
{
	int b[1000];//创建足够大的空间
	int a = 0;
	a++;
	return a;
}
int main()
{
	int& c = func();
	cout << c << endl;
	cout << c << endl;
	return 0;
}