C++的引用

引用

#define _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include <iostream>
#include <stdarg.h>

using namespace std;

void main() {
	//变量名-门牌号（内存空间0X00001的别名，可不可以有多个名字？）
	int a = 10;
	//b就这个内存空间另外一个别名
	//& C++中的引用
	int &b = a;
	cout << b << endl;
	getchar();
}

指针值交换 引用值交换

#define _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include <iostream>
#include <stdarg.h>

using namespace std;

//指针值交换
/*
void swap_1(int *a,int *b) {
	int c = 0;
	c = *a;
	*a = *b;
	*b = c;
}

//引用值交换
void swap_2(int &a,int &b) {
	int c = 0;
	c = a;
	a = b;
	b = c;
}

void main() {
	int x = 10;
	int y = 20;
	printf("%d,%d\n",x,y);
	swap_1(&x,&y);
	//a成了x的别名
	//swap_2(x,y);
	printf("%d,%d\n", x, y);
	getchar();
}

引用的主要功能，作为函数的参数或返回值

struct Teacher
{
	char *name;
	int age;
};

void myprint(Teacher &t) {
	cout << t.name << "," << t.age << endl;
	t.age=24;
}

void myprint2(Teacher *t) {
	cout << t->name << "," << t->age << endl;
}
//引用的主要功能，作为函数的参数或返回值
void main() {
	Teacher t;
	t.name = "jack";
	t.age = 20;
	myprint(t);
	myprint2(&t);
	getchar();
}

指针的引用，代替二级指针

void main() {
	//指针常量，指针的常量，不改变地址的指针，但是可以修改它指向的内容
	int a = 2, b = 3;
	int * const p1 = &a;
	//p1 = &b; //NO
	*p1 = 4;

	//常量指针，指向常量的指针，内容不能修改
	const int *p2 = &a;
	p2 = &b;
	//*p2 = 9; //NO
}

//1.单纯给变量取别名没有任何意义，作为函数参数传递，能保证参数传递过程中不产生副本

//2.引用可以直接操作变量，指针要通过取值(*p)，间接操作变量，指针的可读性差

//常引用类似于java中的final

void myprintf(const int &a) {
	cout << a << endl;
}

void main() {
	//const int a;
	//引用必须要有值，不能为空
	//int &a = NULL;

	//常引用
	int a = 10, b = 9;
	const int &c = a;

	//字面量
	const int &d = 70;
	//c=d
	myprintf(c);
	getchar();
}

引用的大小

struct Teacher {
	char name[20];
	int age;
};

void main() {
	Teacher t;
	Teacher &t1 = t;
	Teacher *p = &t;
	cout << sizeof(t1) << endl;
	cout << sizeof(p)<< endl;
	getchar();
}

struct Teacher
{
	char name[20];
	int age;
};

void myprint(Teacher *t) {
	cout << t->name << "," <<t ->age << endl;
}

void myprint2(Teacher &t) {
	cout << t.name << "," << t.age << endl;
	t.age = 21;
}

void main() {
	Teacher t;
	Teacher *p = NULL;
	//报错，防止不报错，进行非空判断
	myprint(p);
	//引用不能为空，没法传进去
	//Teacher &t2 = NULL;
	//myprint2(t2);
	getchar();
}

//函数默认参数

void myprint(int x ,int y= 9 ,int z= 8) {
	cout << x << endl;
}
//重载
void myprint(int x ,bool ret) {
	cout << x << endl;
}

void main() {
	myprint(20);
	getchar();
}

//可变参数

//java中int

void func(int i ,...) {
	//可变参数指针
	va_list args_p;
	//开始读取可变参数，i是最后一个固定参数
	va_start(args_p,i);
	int a = va_arg(args_p,int);
	char b = va_arg(args_p, char);
	int c = va_arg(args_p, int);
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
	va_end(args_p);
}

void main() {
	func(9,24,'b',58);
	getchar();
}

循环读取

void func(int i ,...) {
	//可变参数指针
	va_list args_p;
	//开始读取可变参数，i是最后一个固定参数
	va_start(args_p,i);
	int value;
	while (1)
	{
		value = va_arg(args_p,int);
		if (value<0)
		{
			break;
		}
		cout << value << endl;
	}

	//结束
	va_end(args_p);
}

void main() {
	func(9,120,4,90);
	getchar();
}

MyTeacher.h

#pragma once
class MyTeacher {
public :
	char *name;
	int age;
public :
	void setAge(int age);
	int getAge();
	void setName(char *name);
	char* getName();
};

#include "MyTeacher.h"

void MyTeacher::setAge(int age) {
	this->age = age;
}

int MyTeacher::getAge() {
	return this->age = age;
}

void MyTeacher::setName(char *name) {
	this->name = name;
}

char* MyTeacher::getName() {
	return this->name = name;
}

C++类的普遍写法

#include "MyTeacher.h"
void main() {
	MyTeacher t1;
	t1.name = "Jack";
	t1.age = 20;
	cout << t1.getName() << endl;
	getchar();
}