c++学习记录1

c++学习记录，仅作代码保存

#include <iostream>
using namespace std;
#include <string.h>
/*
int* func()
{
	//c使用malloc开辟内存，c++使用new
	int* p = new int(10);//创建一个变量，这个变量存放10
	return p;
}
void test()
{
	//创建10个整型数据的数组，在堆区
	int * arr=new int[10];
	for (int i = 0; i < 10; i++)
	{
		arr[i] = i;
	}
	for (int i = 0; i < 10; i++)
	{
		cout << arr[i] << endl;
	}
	//释放数组
	delete[]arr;
}
int main()
{
	int* p = func();
	test();
	cout << *p << endl;
	//释放内存
	delete p;
}
*/
//引用：给变量起别名
/*
int main()
{
	int a = 5,c=10;
	int& b = a;
	//1、引用必须要初始化
		//int& b;//err
	//2、引用一旦初始化后，就不能更改
		//b = c;//这是赋值操作，不是更改引用
	//修改别名等于修改本身
	b = 10;
	cout << a << endl;//10
	cout << b << endl;//10
}
*/
//引用传递
/*
void myswap(int &a,int &b)
{
	int temp = a;
	a = b;
	b = temp;
}
int main()
{
	int a = 10, b = 20;
	myswap(a, b);
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
	return 0;
}
*/
//引用做函数的返回值
//1、不要返回局部变量的引用
//2、函数调用可以作为左值
/*
int& test1()
{
	int a = 10;
	return a;
}
int& test2()
{
	static int a = 10;//静态变量
	return a;
}
int main()
{
	int& ref = test1();
	cout << ref << endl;//第一次正确，是因为编译器做了保留
	cout << ref << endl;//第二次错误，因为a的内存已经释放

	int& ref2 = test2();
	cout << ref2 << endl;
	cout << ref2 << endl;
	test2() = 1000;//如果函数的返回值是引用，这个函数调用可以作为左值
	cout << ref2 << endl;
	cout << ref2 << endl;
}
*/
//引用的本质就是一个指针常量
/*
int main()
{
	int a = 10;
	int& b = a;
	int* const b = &a;
}
*/
//常量引用
/*
int main()
{
	int a = 10;
	//加上const之后，编译器将代码修改int temp =10;const int& ref=temp;
	const int& ref = 10;//加入const之后就不能修改了
}
*/
//函数的默认参数
//1、默认参数只能从后往前写
//2、如果函数的声明有默认参数，函数的实现就不能有默认参数
/*
int func(int a, int b=20, int c=30)
{
	return a + b + c;
}
int main()
{
	cout << func(10,30) << endl;
}
*/
//函数占位参数
//占位参数可以是默认参数
/*
void func2(int a, int = 10);
void func(int a,int)
{
	cout << "asdf" << endl;
}
int main()
{
	//func(10);err
	func(10, 10);
}
*/
//函数重载的满足条件
//1、在同一个作用域下
//2、函数的名称相同
//3、函数的参数不同，或者个数不同，或者顺序不同
//4、函数的返回值不能是返回值不同的函数
/*
void func()
{
	cout << "func的调用!" << endl;
}
void func(int a)
{
	cout << "func的调用!（int a）" << endl;
}
void func(int a, double b)
{
	cout << "func的调用!（int a,double b）" << endl;
}
void func(double a,int b)
{
	cout << "func的调用!（double a,int b）" << endl;
}

int main()
{
	//通过传入参数的不同，运行不同的函数
	func();
	func(10);
	func(10, 2.2);
	func(2.2, 10);

	return 0;
}
*/
//函数重载的注意事项
//1、引用作为函数重载的条件
//2、函数重载碰到默认参数
/*
void func(int& a)//int &a=10;不合法
{
	cout << "func(int &a)" << endl;
}
void func(const int& a)//const int& a=10;合法
{
	cout << "func(const int &a)" << endl;
}
void func2(int a)
{
	cout << "func2(int a)" << endl;
}
//void func2(int a,int b=10)
//{
//	cout << "func2(int a,int b)" << endl;
//}
int main()
{
	int a = 10;
	func(a);
	func(10);
	func2(a);//省去默认参数时，编译器不知道调用哪个函数
	return 0;
}
*/
//权限：将属性和行为作为一个整体来表现事物
/*
const double pi = 3.14;
//设计一个圆类，求圆的周长
class Circle
{
	//访问权限
public://公共权限
	//属性
	int m_r;//半径
	//行为
	double calculatezc()//周长
	{
		return 2 * pi * m_r;
	}
};
int main()
{
	//通过一个类，创建一个对象
	Circle c1;
	c1.m_r = 10;//定义属性
	cout << "圆的周长:" << c1.calculatezc() << endl;
	return 0;
}
*/
//设计一个学生类，属性有姓名和学号
/*
class student
{
public://公共权限
	//类中的属性和行为，统称为成员
	//属性==成员属性==成员变量
	//行为==成员函数==成员方法
	string m_name;//姓名
	int m_id;//学号
	void showstudent()
	{
		cout << "姓名：" << m_name << " 学号：" << m_id << endl;
	}
	void setname(string name)
	{
		m_name = name;
	}
	void setid(int id)
	{
		m_id = id;
	}
};
int main()
{
	//实例化对象
	student s1;
	//s1.m_name = "zhangsan";
	s1.setname("zhangsan");
	//s1.m_id = 1;
	s1.setid(1);
	//显示信息
	s1.showstudent();

	student s2;
	s2.m_name = "lisi";
	s2.m_id = 2;
	s2.showstudent();

	return 0;
}
*/
//三种访问权限
//1、public		公共权限	成员在类内可以访问，类外可以访问
//2、protected	保护权限	成员在类内可以访问，类外不可以访问	子类可以访问父类的保护内容
//3、private	私有权限	成员在类内可以访问，类外不可以访问	子类不可以访问父类的私有内容
/*
class person
{
public:
	//公共权限
	string m_name;//姓名
protected:
	//保护权限
	string m_car;//汽车
private:
	//私有权限
	int m_password;//密码
public:
	void func()
	{
		m_name = "zhangsan";
		m_car = "tuolaji";
		m_password = 123456;
	}
};
int main()
{
	person p1;
	p1.m_name = "lisi";
	//p1.m_car不能访问
	return 0;
}
*/
//struct 和 class 的区别为默认的访问权限不同
//struct 默认权限为public
//class 默认权限为private
/*
class c1
{
	int m_a;//私有
};
struct c2
{
	int m_a;
};
int main()
{
	c1 c1;
	//c1.m_a = 100;不可访问
	c2 c2;
	c2.m_a = 100;//可以访问
	return 0;
}
*/
//成员属性设为私有
//1、可以控制读写权限
//2、对于写可以检测数据的有效性
/*
class person
{
public:
	//写姓名
	void setname(string name)
	{
		m_name = name;
	}
	//读姓名
	string getname()
	{
		return m_name;
	}
	//设置年龄
	void setage(int age)
	{
		if (age < 0 || age>150)
		{
			m_age = 0;
			cout << "age:err" << endl;
			return;
		}
		m_age = age;
	}
	//获取年龄 可读可写 如果想修改（0-150）
	int getage()
	{
		return m_age;
	}
	//写情人
	void setlover(string lover)
	{
		m_lover = lover;
	}
private:
	string m_name;//姓名 可读可写
	int m_age;//年龄 
	string m_lover;//情人 只写
};
int main()
{
	person p;
	p.setname("zhangsan");
	p.setlover("lisi");
	cout << "姓名：" << p.getname() << endl;
	p.setage(2000);
	cout << "年龄：" << p.getage() << endl;
	return 0;
}
*/
//设计立方体，求出立方体的面积和体积
//创建立方体的类
//设计属性
//设计行为
//利用成员函数来判断两个立方体是否相等
/*
class cube
{
private:
	//属性
	int m_l;
	int m_w;
	int m_h;
public://行为
	//设置长
	void  setl(int l)
	{
		m_l = l;
	}
	//获取长
	int getl()
	{
		return m_l;
	}
	//设置宽
	void  setw(int w)
	{
		m_w = w;
	}
	//获取宽
	int getw()
	{
		return m_w;
	}
	//设置高
	void  seth(int h)
	{
		m_h = h;
	}
	//获取高
	int geth()
	{
		return m_h;
	}
	//获取立方体面积
	int calculates()
	{
		return (m_l * m_h + m_l * m_w + m_l * m_w) * 2;
	}
	//获取立方体体积
	int calculatev()
	{
		return m_l * m_h * m_w;
	}
	bool issamebyclass(cube& c)
	{
		if (m_l== c.getl() &&m_w == c.getw() && m_h == c.geth())
		{
			return true;
		}
		return false;
	}
};
//利用全局函数判断，两个立方体是否相等
bool issame(cube& c1, cube& c2)
{
	if (c1.getl() == c2.getl() && c1.getw() == c2.getw() && c1.geth() == c2.geth())
	{
		return true;
	}
	return false;
}
int main()
{
	cube c1;
	c1.setl(10);
	c1.seth(10);
	c1.setw(10);
	cout << "c1的面积S=" << c1.calculates() << endl;
	cout << "c1的体积V=" << c1.calculatev() << endl;
	cube c2;
	c2.setl(10);
	c2.seth(10);
	c2.setw(10);
	cout << "c2的面积S=" << c2.calculates() << endl;
	cout << "c2的体积V=" << c2.calculatev() << endl;
	//利用全局函数判断
	bool ret = issame(c1, c2);
	if (ret)
	{
		cout << "==" << endl;
	}
	else
	{
		cout << "!=" << endl;
	}
	//利用成员函数判断
	ret = c1.issamebyclass(c2);
	if (ret)
	{
		cout << "==" << endl;
	}
	else
	{
		cout << "!=" << endl;
	}
	return 0;
}
*/
//判断点和圆的关系
//点到圆心的距离判断在圆上，圆外，圆内
//r*r = (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)
/*
class point
{
private:
	int m_x;
	int m_y;
public:
	void setx(int x)
	{
		m_x = x;
	}
	int getx()
	{
		return m_x;
	}
	void sety(int y)
	{
		m_y = y;
	}
	int gety()
	{
		return m_y;
	}
};
class circle
{
private:
	int m_r;//半径
	point m_center;
public:
	void setr(int r)
	{
		m_r = r;
	}
	int getr()
	{
		return m_r;
	}
	void setcenter(point center)
	{
		m_center = center;
	}
	point getcenter()
	{
		return m_center;
	}
};
void isincircle(circle& c, point& p)
{
	//计算两点距离的平方
	int distance = ((c.getcenter().getx() - p.getx()) * (c.getcenter().getx() - p.getx())) +
		((c.getcenter().gety() - p.gety()) * (c.getcenter().gety() - p.gety()));
	//计算半径的平方
	int rdistance = c.getr() * c.getr();
	if (distance == rdistance)
	{
		cout << "点在圆上" << endl;
	}
	else if (distance > rdistance)
	{
		cout << "点在圆外" << endl;
	}
	else
	{
		cout << "点在圆内" << endl;
	}
}
int main()
{
	//创建圆
	circle c;
	c.setr(10);
	point center;
	center.setx(10);
	center.sety(0);
	c.setcenter(center);

	//创建点
	point p;
	p.setx(10);
	p.sety(10);

	//判断
	isincircle(c, p);
	return 0;
}
*/
//对象的初始化和清理( 构造函数 析构函数)
/*
class person
{
	//1、构造函数
	//没有返回值 不用写void
	//函数名与类名相同
	//构造函数可以有参数，可以发生重载
	//创建对象的时候，构造函数会自动调用，而且只调用一次
public:
	person()
	{
		cout << "person构造函数的调用" << endl;
	}
	//2、析构函数	进行删除操作
	//没有返回值 不用写void
	//函数名与类名相同 在名称前加~
	//析构函数不可以有参数，不可以发生重载
	//对象在销毁前，会自动调用析构函数，而且只调用一次
	~person()
	{
		cout << "person析构函数的调用" << endl;
	}
};
//构造函数和析构函数都是必须有的实现，如果我们不写，系统会自动实现，不过是空实现
void test01()
{
	person p;
}
int main()
{
	person p;
	system("pause");
	return 0;
}
*/