练习day1（基础练习）

2021-10-13 15:31:25 阅读：139 来源： 互联网

标签：std const cout int 练习基础 day1 using include

转载：CPlusPlusThings/practical_exercises/10_day_practice/day1 at master · Light-City/CPlusPlusThings · GitHub

代码是自己另外网上荡的，与原网站不同

1.是否闰年

#include<iostream>
using namespace  std;
int main(int argc, char const *argv[])
{
	int year;
	bool isLeapyear;
	cout << "please enter year" << endl;
	cin >> year;
	isLeapyear = (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0));
	if (isLeapyear)
		cout << "yes" << endl;
	else
		cout << "no" << endl;
	system("pause");
	return 0;
}

2.联合体学习

#include<iostream>
using namespace  std;

union muun {
	struct { int x; int y; int z; }u;
	int k;
	int i;
	int j;
}a;
int main()
{
	a.u.x = 1;
	a.u.y = 2;
	a.u.z = 3;
	a.k = 4;//会覆盖掉结构体u中的第一个元素，我也不懂为什么是覆盖第一个而不是第二个
	printf("%d %d %d %d\n", a.u.x, a.u.y, a.u.z, a.k);
	return 0;
}

结构体：把不同类型的数据组合成一个整体。所占内存长度是各成员占的内存长度的总和。所以一个int k只能覆盖掉一个int x。应该是这样的

3.x的n次方

#include<iostream>
using namespace  std;
double power(double x, int n);
int main(int argc, char const argv[])//这是main函数的一种相对比较标准的写法
{
	double x=0.0;//局部变量会随机初始化
	int n=0;
	cout << "please enter x and n" << endl;
	cin >> x >> n;
	cout << x << "的" << n << "次方等于" << power(x, n) << endl;
	return 0;
}

double power(double x, int n)
{
	double val = 1.0;
	while (n--)
		val *= x;
	return val;
}

4.掷骰子（用类的方式）

#include<iostream>
#include<ctime>
using namespace  std;
class dice {
public:
	int getNumber();
private:
	int number;
};

int main()
{
	dice d;
	cout << d.getNumber() << endl;
	return 0;
}


int dice::getNumber()
{
	srand((unsigned)time(NULL));//生成随机数种子
	number = rand() % 6 + 1;
	return number;

}

5，枚举类型

#include<iostream>
using namespace  std;
//在方法的参数列表中定义参数类型为枚举类，那么在传参时，参数值只能从枚举类的枚举项中选择，不会出现乱写现象。
enum weekday
{
	monday,tuesday,wednesday,thursday,friday,saturday,sunday
};

int main(int argc, char const *argv[])
{
	enum weekday wek = monday;
	for (weekday i = wek; i != saturday; i++)
	{
		cout << i << endl;
		cout << wek + monday << endl;
	}
	return 0;
}

6.汉诺塔

转载：汉诺塔问题的的c++实现_GinSmile的博客-CSDN博客_汉诺塔c++

在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘，求把圆盘从下面开始按大小顺序重新摆放在另一根柱子上需要移动多少次。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。

解答：

我们可以拿n=3的时候举例子：

易知f（1）=1，f（2）=3，f（3）=7……；

当n=2时候（1，2，3分别表示小中大三块盘子）：

当n=3时候：

n=3的前三步就是重复n=2时候，把小的两块移动到另一个一个柱子。

然后就是将3移动到另一块柱子上，在继续重复n=2把小的两块移动到另一个（指存在3的一个）柱子上。

扩展到n，即f（n）=2*f（n-1）+1

为了解决这个问题，不妨假设已经知道怎样移动N-1个圆环了。现在，为了把起点盘A盘上的圆环移动到目标盘C盘，假设盘子分别为ABC：

1、把N-1个圆环从A盘移动到（当前）没有任何圆环的过度盘B盘；
2、把最后一个圆环从A盘移动到C盘；
3、把N-1个圆环从B盘移动到C盘（模仿1和2的操作方法来分解问题求解）。

#include<iostream>
using namespace  std;
/*为了解决这个问题，不妨假设已经知道怎样移动N-1个圆环了。现在，为了把起点盘A盘上的圆环移动到目标盘C盘，假设盘子分别为ABC：

1、把N-1个圆环从A盘移动到（当前）没有任何圆环的过度盘B盘；
2、把最后一个圆环从A盘移动到C盘；
3、把N-1个圆环从B盘移动到C盘（模仿1和2的操作方法来分解问题求解）。
*/
void hannoi(int n, char A, char B, char C)
{
	if (n == 1)
		cout << "将圆盘" << n << "从" << A << "放到" << C << endl;
	else {
		hannoi(n - 1, A, C, B);//1、把N-1个圆环从A盘移动到（当前）没有任何圆环的过度盘B盘；
		cout << "将圆盘" << n << "从" << A << "移动到" << C << endl;
		hannoi(n - 1, B, A, C);//3、把N-1个圆环从B盘移动到C盘
	}
}

int main()
{
	int n = 0;
	cout << "请输入圆盘个数" << endl;
	cin >> n;
	hannoi(n, 'A', 'B', 'C');
	return 0;
}

7.结构体

#include<iostream>
using namespace  std;
struct student {
	int num;
	char name[10];
	char gender;
};

int main(int argc, char const *argv[])
{
	student s = { 10,"assd",'m' };
	cout << s.num << endl;
	cout << sizeof(s.num) << endl;//0
	cout << sizeof(s.name) << endl;//
	cout << sizeof(s.gender) << endl;
	cout << sizeof(s)<<endl;
	/*  偏移量指的是结构体变量中成员的地址和结构体变量地址的差。结构体大小等于最后一个成员的偏移量加上最后一个成员的大小。
	显然，结构体变量中第一个成员的地址就是结构体变量的首地址。比如上面的结构体，第一个成员a的偏移量为0。
	第二个成员b的偏移量是第一个成员的偏移量加上第一个成员的大小（0+4）,其值为4；第三个成员c的偏移量是第二个成员的偏移量应该是加上第二个成员的大小（4+1）。
*/
	return 0;
}

8.函数综合练习题
一圆型游泳池如图所示，现在需在其周围建一圆型过道，并在其四周围上栅栏。栅栏价格为35元/米，过道造价为20元/平方米。
过道宽度为3米，游泳池半径由键盘输入。要求编程计算并输出过道和栅栏的造价。
图形描述：大圆嵌套小圆：
小圆在大圆中间，小圆为游泳池，大圆与小圆间隔为过道。

#include<iostream>
#include<math.h>
using namespace  std;
const float PI = 3.14;
const float FencePrice = 35;
const float ConcretePrice = 20;
class Circle {
public:
	Circle(float r);
	float FencePerimeter()const;//该函数为只读函数，不允许修改其中的数据成员的值。
	float Area()const;

private:
	float radius;
};
Circle::Circle(float r)
{
	radius = r;
}
float Circle::FencePerimeter()const {
	return 2 * PI*radius + 2 * PI*(radius + 3);
}
float Circle::Area()const
{
	return PI * (pow((radius + 3),2 )-pow(radius,2));
}
int main()
{
	
	cout << "请输入游泳池半径" << endl;
	int r = 0;
	cin >> r;
	Circle c(r);
	
	cout << "栅栏造价:" << c.FencePerimeter()*FencePrice << endl;
	cout << "过道造价:" << c.Area()*FencePrice << endl;
	return 0;
}

9.类前向声明

/*
使用前向引用声明虽然可以解决一些问题，但它并不是万能的。需要注意的是，
尽管使用了前向引用声明，但是在提供一个完整的类声明之前，不能声明该类的对象，
也不能在内联成员函数中使用该类的对象。请看下面的程序段：
*/

//第一种
#include<iostream>
class Fred;	//前向引用声明
class Barney {
   Fred x;	//错误：类Fred的声明尚不完善
};
class Fred {
   Barney y;
};


//第二种
class Fred;	//前向引用声明
 
class Barney {
 public:
   void method()
   {
     x->yabbaDabbaDo();	//错误：Fred类的对象在定义之前被使用
   }
 private:
   Fred* x;   //正确，经过前向引用声明，可以声明Fred类的对象指针
 };
 
class Fred {
 public:
   void yabbaDabbaDo();
 private:
   Barney* y;
}; 

/*
总结：当使用前向引用声明时，只能使用被声明的符号，而不能涉及类的任何细节。
*/

10.静态成员函数

/*
知识点：
静态成员函数
类外代码可以使用类名和作用域操作符来调用静态成员函数。
静态成员函数只能引用属于该类的静态数据成员或静态成员函数。
*/
#include<iostream>
using namespace std;
class Application
{ 
public:
    static void f(); 
    static void g();
private:
    static int global;
};
int Application::global=0;
void Application::f()
{  global=5;}
void Application::g()
{  cout<<global<<endl;}

int main()
{
    Application::f();
    Application::g();
    system("pause");
    return 0;
}


#include<iostream>
using namespace std;
class A
{
    public:
        static void f(A a);
    private:
        int x;
};
void A::f(A a)
{
   
    //静态成员函数只能引用属于该类的静态数据成员或静态成员函数。
    // cout<<x; //对x的引用是错误的
    cout<<a.x;  //正确
}

int main(int argc, char const *argv[])
{
    A a;
    a.f(A());
    system("pause");
    return 0;
}

11.静态数据成员

/*
学习知识：
静态数据成员
用关键字static声明
该类的所有对象维护该成员的同一个拷贝
必须在类外定义和初始化，用(::)来指明所属的类。
*/
#include <iostream>
using namespace std;
class Point	
{
public:	
	Point(int xx=0, int yy=0) {X=xx; Y=yy; countP++; } 
    Point(Point &p);	
	int GetX() {return X;}
	int GetY() {return Y;}
	void GetC() {cout<<" Object id="<<countP<<endl;}
private:	
	int X,Y;
    //静态数据成员，必须在外部定义和初始化，内部不能直接初始化！
	static int countP;
};
Point::Point(Point &p)
{	X=p.X;
	Y=p.Y;
	countP++;
}
//必须在类外定义和初始化，用(::)来指明所属的类。
int Point::countP=0; 
int main()	
{	Point A(4,5);	
	cout<<"Point A,"<<A.GetX()<<","<<A.GetY();
	A.GetC();	
	Point B(A);	
	cout<<"Point B,"<<B.GetX()<<","<<B.GetY();
	B.GetC();	
    system("pause");
    return 0;
}

标签：std,const,cout,int,练习,基础,day1,using,include
来源： https://blog.csdn.net/god_father_o/article/details/120740865

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

练习day1（基础练习）