引用型变量(试题)和成员函数

---

堆空间申请释放

在堆空间上分配和释放指针数组；

NULL指针变量：
a)C语言开始有一个NULL定义，必须包含stdio.h头文件
b)C++11给出了null_ptr关键字;
const char* ps[] = {“abc”,“efg”,“test”,NULL};

const char* ps[] = {"abc","efg","test",NULL};

#include<iostream>
void Print(const char* p[])
{
	while (*p)
	{
		puts(*p++);
	}
}
int main()
{
	const char* ps[] = {"abc","efg","test",NULL};
	auto p = new const char* [4] {"abc", "efg", "test", NULL}; 
	const char** q = new const char* [] {"abc", "efg", "test","wdw", NULL};

	Print(p);
	Print(q);
	delete []p;
	delete []q;
	return 0;
}

在堆空间上分配和释放二维数组；
double ds[3][12] = {89.8,66.4,77.99};

 #include<iostream>
int main()
{

	//C++98支持二维数组（不支持初始化）double[12] *p =double[3][12]
	double ds[3][12] = { 89.8,66.4,77.99 };
	auto p = new double[3][12]; // double(*p)[12] =new double[3][12]; double[12] *p =double[3][12]  3个double 12
	auto q = new double[3][12]{ {12.3,123.2} ,{43.3}, {213,123.5} };
	delete []p;
	delete []q;
	return 0;
}

一、引用型变量

a)C++掩盖真相的语法之一，其内部真实原理就是指针变量。
b)引用做参数时主调函数好用，替你取地址，被调函数也好用，不用*符号；
c)类似于指针常量，指针常量的意思就是指向某个地址，在生命期内再不能改了；
d)另外指针常量的特点是必须初始化，引用型变量必须在定义的同时挂在某个变量上。

#include<iostream>
void Input1(double* p)
{
	*p = 999.9;
}
void Input(double& d)
{
	d = 888.88;
}
int main()
{
	double d1, d2;
	Input(d1); //取地址
	Input1(&d2);
	return 0;
}

引用型变量也是有地址的

#include<iostream>
 int main()
{
	int m = 888;

	int& n = m; //等价于 int* p =&m; 引用也叫做别名变量 引用变量也是有地址的
	n = 999; //等价于* p =999;

	 
	return 0;
}
 

引用型变量必须挂载在某个地址上

#include<iostream>
int main()
{
	int m = 999,n=-1;
//	int& k; //引用变量k 必须挂在某个地址上 挂在 p=&n
	int& k = n;  //要赋值 一变都变
	k = 0;
	k = m; //这个语句是赋值不是挂载语法 挂载就是指向 不是地址在赋值 而是内容
	int* const p = &m; //必须初始化，不能指向其他

	return 0;
}

引用型变量的使用

#include<stdio.h>

void swap(int& i ,int& j) //别名变量 代理变量 引用变量（内部帮你取地址了）就是指针变量
{
	int temp = i;
	i = j;
	j = temp;
}
int main()
{
	int x = 10;
	int y = 20;
	swap(x, y);
	return 0;
}

二、成员函数

C++下成员函数实际上是在全局写这，只不过有相应的函数指针来调用

#include <iostream>
using namespace std;
/*
实际上成员函数实在结构体外面
对成员函数的调用就是指向了结构体中的指向的那一部分
*/
struct SData	
{
	int x;
	int y; //成员变量
	void Print() //面向对象函数 成员函数 不占结构体空间 实际上是在外面
	{
		cout << "x=" << x << ",y=" << y << endl;
	}  //含有函数的结构体就是升级的结构体变成了类

	void Set(int a, int b)
	{
		x = a;
		y = b;
	}
};
void Print()   //全局函数
{

}
int main()
{
	SData d1 = { 3,5 }, d2 = { -1,2 }, d3 = {4,9};
	//不同的对象打印出来的是不同的 面向你的对象取打印
	d1.Print();
	d3.Print();

	d1.Set(111, 222);
	d1.Print();

	return 0;
}

C语言下的实际成员函数

#include<stdio.h>
struct SData
{
	int x; 
	int y;
};
void Print(struct SData* pObject) //面向对象C
{
	printf("x=%d,y=%d\n", pObject->x, pObject->y);
}
int main()
{
	struct SData d1 = { 3,5 }, d2 = { -1,2 }, d3 = { 4,9 };
	Print(&d1);
	Print(&d2);
	return 0;
}

引用型变量原理试题

将代码改为C语言代码，要求在.c文件中能编译通过(要提交.c文件)
通过本题目理解引用型变量的原理

swap

void swap(int& i, int& j)
{
    int tmp = i;
    i = j;
    j = tmp;
}

void main()
{
	int x = 10;
	int y = 20;
	swap(x, y);
}

答案：

 #include<stdio.h>
void swap(int* i, int* j)
{
	int temp = *i;
	*i = *j;
	*j = temp;
}
int main()
{
	int x = 10;
	int y = 20;
	swap(&x, &y);
}

Circle

2、 将以下类反编成C语言，要求在.c文件中能编译通过(要提交.c文件)
通过本题目理解C++类成员函数的原理以及this指针变量的原理。

游泳池的地面是瓷砖铺成，外围有铁栅栏是正圆，内部是游泳池也是正圆。
假设游泳池的甬道是宽3米，编写代码当输入一个游泳池的半径后，
打印出提栅栏的周长和瓷砖甬道的面积。

#include <iostream>
using namespace std;
const float PI = 3.14159f;

struct Circle
{
    float   radius;

    float Circumference()  //圆周长
	{
		return 2 * PI * radius;
	}
    float Area()  //圆面积
	{
		return PI * radius * radius;
	}

};

void main ()
{
  float radius;
 
  cout<<"请输入游泳池的半径: ";
  cin>>radius;

  // 声明 Circle 对象
  Circle Pool = {radius};
  Circle PoolRim = {radius + 3};  
//计算栅栏长度
  cout<<"栅栏长度是："<<PoolRim.Circumference()<<endl;

 cout << "甬道的面积是："<<PoolRim.Area()-Pool.Area() << endl;

}

答案：

#include<stdio.h>
const float PI = 3.1415926f;

struct Circle
{
	float radius;
};
float CircleLength(struct Circle* a)
{
	return 2 * PI * a->radius;
}
float CircleArea(struct Circle* b)
{
	return PI * b->radius * b->radius;
}

int main()
{
	float radius;
	printf("请输入圆的半径: ");
	scanf_s("%f", &radius);


	struct Circle Pool = { radius };
	struct Circle PoolRim = { radius + 3 };

	printf("游泳池周长：%f", CircleLength(&PoolRim));
	printf("游泳池面积：%f",  CircleArea(&PoolRim)-CircleArea(&Pool));
	 
}