#Pyhon 3 猜数字挑战小游戏
import random
while True:
LEVEL = input("1：低级；2：中级； 3：高级。 请选择游戏难度: ");
if LEVEL == '1': MAX_TIMES = 10
elif LEVEL == '2': MAX_TIMES = 7
else: MAX_TIMES = 5
while True:
begin = random.randint(1, 1000)
end = random.randint(1, 1000)
if abs(end - begin) > 100:
break
if begin > end:
begin, end = end, begin
num = random.randint(begin, end)
print("电脑我心里有一个{}到{}之间的整数，小子你能猜到这个数字吗？".format(begin, end))
print("想作弊，输入"开外挂"；否则回车直接开始挑战我")
if input() == "开外挂":
print("我心里想的是数字{}，你可以直接说出来就赢我了".format(num))
times = 0
while times < MAX_TIMES:
try:
_guess = input("我心中的数字是多少：")
guess = int(_guess)
except ValueError:
if _guess == "开外挂":
print("我心里想的是数字{}，你可以直接说出来就赢我了".format(num))
else:
print("大兄弟，要猜数字。重来!")
continue
if guess == num:
print("你赢了，我甘拜下风")
break
elif guess < num:
print("猜小了，游戏继续")
else:
print("猜大了，游戏继续")
times += 1
else:
print("大兄弟，都猜了{}次了，你都没猜对。You loser".format(MAX_TIMES))
again = input("再来一局？Yes or No: ").upper()
if not (again == 'YES' or again == 'Y'):
break
//类是封装成员函数的结构体
#include <iostream>
using namespace std;
struct student {
int sno;
char name[20];
int grade;
void baochengji()
{
cout << "my grade is " << grade << endl;
}
};
int main()
{
struct student yangzhu;
yangzhu.sno = 19;
yangzhu.grade = 62;
yangzhu.baochengji();//baochengji(yangzhu);
return 0;
}
//成员函数类外实现
#include <iostream>
using namespace std;
class Student {
public:
int sno;
char name[20];
int grade;
void baochengji();
};
void Student::baochengji()
{
cout << "my grade is " << grade << endl;
}
int main()
{
Student yangzhu;
yangzhu.sno = 19;
yangzhu.grade = 62;
yangzhu.baochengji();//baochengji(yangzhu);
return 0;
}
//成员函数重载
#include <iostream>
using namespace std;
class Student {
public:
int sno;
//int sno;
char name[20];
int grade;
void baochengji();
void baochengji(int plus);
};
void Student::baochengji()
{
cout << "my grade is " << grade << endl;
}
void Student::baochengji(int plus)
{
cout << "my grade is " << grade + plus << endl;
}
int main()
{
Student yangzhu;
yangzhu.sno = 19;
yangzhu.grade = 62;
yangzhu.baochengji();//baochengji(yangzhu);
yangzhu.baochengji(20);
return 0;
}
//构造函数
#include <iostream>
using namespace std;
class Student {
public:
Student() { sno = 19; grade = 62; }
Student(int mysno, int mygrade) { sno = mysno; grade = mygrade; }
int sno;
char name[20];
int grade;
void baochengji();
};
void Student::baochengji()
{
cout << "my grade is " << grade << endl;
}
int main()
{
Student yangzhu, zhangsan(11, 99);
//cout << "yangzhu" << endl;
yangzhu.baochengji();
zhangsan.baochengji();
return 0;
}
//析构函数
#include <iostream>
#include <cstring>
#include <cstdlib>
using namespace std;
class Student {
public:
Student() { sno = 19; grade = 62; }
Student(int mysno, int mygrade, char myname[])
{
sno = mysno; grade = mygrade;
name = (char *)malloc(strlen(myname)+1);
strcpy(name, myname);
}
~Student() { cout << "in destructor" << endl; free(name); }
int sno;
char *name;
int grade;
void baochengji();
};
void Student::baochengji()
{
cout << "I'm " << name << ", my grade is " << grade << endl;
}
int main()
{
Student zhangsan(11, 99, "zhangsan2");
zhangsan.baochengji();
cout << "yangzhu" << endl;
return 0;
}
//拷贝构造函数
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
using namespace std;
class Student {
public:
Student() { sno = 19; grade = 62; name = NULL; }
Student(int mysno, int mygrade, char myname[])
{
cout << "in constructor" << endl;
sno = mysno; grade = mygrade;
name = (char *)malloc(strlen(myname)+1);
strcpy(name, myname);
}
Student(const Student & in)//拷贝构造函数
{
cout << "in copy constructor" << endl;
sno = in.sno; grade = in.grade;
name = (char *)malloc(strlen(in.name)+1);
strcpy(name, in.name);
}
~Student() { free(name); }
int sno;
char *name;
int grade;
void baochengji();
};
void Student::baochengji()
{
cout << "I'm " << name << ", my grade is " << grade << endl;
}
int main()
{
Student zhangsan(11, 99, "zhangsan2");//调用普通构造函数
Student yangzhu = zhangsan;//此时系统会自动调用拷贝构造函数
printf("%d %d %p\n", zhangsan.sno, zhangsan.grade, zhangsan.name);
printf("%d %d %p\n", yangzhu.sno, yangzhu.grade, yangzhu.name);
getchar();
return 0;
}
//this指针
#include <iostream>
#include <cstring>
#include <cstdlib>
using namespace std;
class Student {
public:
Student(int sno, int grade, char name[]) //形参与成员属性同名
{
this->sno = sno; this->grade = grade;
this->name = (char *)malloc(strlen(name)+1);
strcpy(this->name, name);
}
~Student() { free(name); }
//每一个对象（例如：yangzhu和zhangsan），都有自己的成员属性
int sno;
char *name;
int grade;
//每一个对象的成员方法的代码是完全一样的，所以应该共享同一份代码
void baochengji() // baochengji(Student *p)
{cout << "I'm " << name << ", my grade is " << this->grade << endl;}
};
/* 从道理上讲，zhangsan和yangzhu两个对象在内存中应该有3部分：
1. zhangsan的成员属性
2. yangzhu 的成员属性
3. zhangsan和yangzhu共享的成员方法的代码
成员方法被调用的时候，系统会传入一个隐含的参数
(指向yangzhu或者zhangsan的指针），以便区分要访哪个对象的成员属性。
这个指针就被称为this指针。
*/
int main()
{
Student zhangsan(11, 99, "zhangsan");
Student yangzhu(12, 60, "yangzhu");
zhangsan.baochengji();//视为baochengji(&zhangsan)
yangzhu.baochengji(); //视为baochengji(&yangzhu)
cout << "yangzhu" << endl;
return 0;
}
//static
#include <iostream>
#include <cstring>
#include <cstdlib>
using namespace std;
class Student {
private:
static int persons;
public:
Student(int mysno, int mygrade, char myname[])
{
persons++;
sno = mysno; grade = mygrade;
name = (char *)malloc(strlen(myname)+1);
strcpy(name, myname);
}
~Student() { free(name); }
int sno;
char *name;
int grade;
void baochengji() { cout << "I'm " << name << ", my grade is " << grade << endl; };
static int getpersons() { return persons; }
};
int Student::persons = 0;
int main()
{
Student zhangsan(11, 99, "zhangsan");
Student yangzhu(12, 60, "yangzhu");
/*
cout << yangzhu.persons << endl;
cout << zhangsan.persons << endl;
cout << Student::persons << endl;
*/
cout << yangzhu.getpersons() << endl;
cout << Student::getpersons() << endl;
return 0;
}
//友员函数
#include <iostream>
#include <cstring>
#include <cstdlib>
using namespace std;
class Student;
class Teacher {
public:
Teacher(int mytno, char myname[])
{
tno = mytno;
name = (char *)malloc(strlen(myname)+1);
strcpy(name, myname);
}
~Teacher() { free(name); }
int tno;
char *name;
void chachengji(const Student & stu);
};
class Student {
int grade;
public:
Student(int mysno, int mygrade, char myname[])
{
sno = mysno; grade = mygrade;
name = (char *)malloc(strlen(myname)+1);
strcpy(name, myname);
}
~Student() { free(name); }
friend void Teacher::chachengji(const Student &);
int sno;
char *name;
};
void Teacher::chachengji(const Student & stu) { cout << stu.grade << endl; }
int main()
{
Student zhangsan(11, 99, "zhangsan");
Teacher yangzhu(33, "yangzhu");
yangzhu.chachengji(zhangsan);
return 0;
}
//内部对象
#include <iostream>
#include <cstring>
#include <cstdlib>
using namespace std;
class Student {
public:
Student(int mysno, int mygrade, char myname[])
{
sno = mysno; grade = mygrade;
strcpy(name, myname);
}
int sno;
char name[20];
int grade;
};
class Teacher {
public:
//ÔÚ³õʼ»¯ÁбíÖжÔÄÚ²¿¶ÔÏó½øÐгõʼ»¯
Teacher(int tno, char name[], Student myassistant): assistant(myassistant)
{
this->tno = tno;
strcpy(this->name, name);
//this->assistant = assistant;
}
int tno;
char name[20];
Student assistant;
};
int main()
{
Student zhangsan(11, 99, "zhangsan");
Teacher yangzhu(133, "yangzhu", zhangsan);
cout << yangzhu.assistant.name << endl;
return 0;
}
//继承基础
#include <iostream>
#include <cstring>
using namespace std;
class Person { //父类 基类
protected: //不允许从外部访问，但是子类可以访问
char name[20];
public:
int no;
void whoami() { cout << "I am " << name << endl; }
};
class Student : public Person {//子类 派生类
public:
int grade;
void study() { cout << "I am studing" << endl;}
Student(int myno, char myname[], int mygrade)
{ no = myno; strcpy(name, myname); grade = mygrade; }
};
class Teacher : public Person { //公有继承、私有继承、保护继承
public:
int salary;
void teach() { cout << "I am teaching" << endl; }
Teacher(int myno, char myname[], int mysalary) { no = myno; strcpy(name, myname); salary = mysalary; }
};
int main()
{
Student zhangsan(19, "zhangsan", 99);
Teacher yangzhu(133, "yangzhu", 7000);
zhangsan.whoami();
zhangsan.study();
yangzhu.whoami();
yangzhu.teach();
// strcpy(yangzhu.name, "abc");
// yangzhu.whoami();
return 0;
}
//使用初始化表完成内嵌父类对象的初始化
#include <iostream>
#include <cstring>
using namespace std;
class Person {
private:
char name[20];
public:
Person(int myno, const char myname[]) { no = myno; strcpy(name, myname); }
int no;
void whoami() { cout << "I am " << name << endl; }
};
class Student : public Person {
public:
int grade;
void study() { cout << "I am studing" << endl;}
Student(int myno, char myname[], int mygrade) : Person(myno, myname), grade(mygrade)
//初始化表也可以用于初始化自身特有（不是继承得到）的属性
{ }
};
class Teacher : public Person {
public:
int salary;
void teach() { cout << "I am teaching" << endl; }
Teacher(int myno, char myname[], int mysalary) : Person(myno, myname)
//在初始化表中指明由父类完成内嵌的父类对象的初始化
{ salary = mysalary; }
};
int main()
{
//从逻辑上看，一个学生对象是由2部分组成：内嵌的父类对象+自己特有的特性
Student zhangsan(19, "zhangsan", 99);
Teacher yangzhu(133, "yangzhu", 7000);
zhangsan.whoami();
zhangsan.study();
yangzhu.whoami();
yangzhu.teach();
return 0;
}
//缺省构造函数
#include <iostream>
#include <cstring>
using namespace std;
class Person {
protected:
char name[20];
public:
//如果不定义任何构造函数，系统会帮你写一个缺省构造函数（无参且不作任何操作）
//一旦定义了构造函数，系统不会再帮你写任何的构造函数
// Person(int myno, char myname[]) { no = myno; strcpy(name, myname); }
Person() { cout << "abc" << endl; }
int no;
void whoami() { cout << "I am " << name << endl; }
};
class Student : public Person {
public:
int grade;
void study() { cout << "I am studing" << endl;}
Student(int myno, char myname[], int mygrade)
//如果没有初始化表，那么系统会自动调用父类的无参构造函数
{ no = myno; strcpy(name, myname); grade = mygrade; }
};
class Teacher : public Person {
public:
int salary;
void teach() { cout << "I am teaching" << endl; }
Teacher(int myno, char myname[], int mysalary) { no = myno; strcpy(name, myname); salary = mysalary; }
};
int main()
{
Student zhangsan(19, "zhangsan", 99);
Teacher yangzhu(133, "yangzhu", 7000);
Person lisi;
lisi.whoami();
zhangsan.whoami();
zhangsan.study();
yangzhu.whoami();
yangzhu.teach();
return 0;
}
//父类指针与子类指针
#include <iostream>
#include <cstring>
using namespace std;
class Person {
private:
char name[20];
public:
Person(int myno, const char myname[]) { no = myno; strcpy(name, myname); }
int no;
void whoami() { cout << "I am " << name << endl; }
};
class Student : public Person {
public:
int grade;
void study() { cout << "I am studing" << endl;}
Student(int myno, char myname[], int mygrade) : Person(myno, myname), grade(mygrade)
{ }
};
class Teacher : public Person {
public:
int salary;
void teach() { cout << "I am teaching" << endl; }
Teacher(int myno, char myname[], int mysalary) : Person(myno, myname)
{ salary = mysalary; }
};
int main()
{
Person *p;
Student *q;
Person lisi(12, "lisi");
Student zhangsan(19, "zhangsan", 99);
Teacher yangzhu(133, "yangzhu", 7000);
p = &lisi;
p = &zhangsan;//父类指针可以指向子类对象
//cout << p->grade << endl; //指向子类对象的父类指针只能访问内嵌的父类对象
cout << p->no << endl;
//q = &lisi; //子类指针不可以指向父类对象
zhangsan.whoami();
zhangsan.study();
yangzhu.whoami();
yangzhu.teach();
return 0;
}
//虚方法与抽象类
#include <iostream>
#include <cstring>
using namespace std;
class Person {//抽象类
private:
char name[20];
public:
Person(int myno, const char myname[]) { no = myno; strcpy(name, myname); }
int no;
void whoami() { cout << "I am " << name << endl; }
//virtual void career() { cout << "I don't know my career" << endl; }
virtual void career() = 0; //纯虚方法
};
class Student : public Person {
public:
int grade;
void study() { cout << "I am studing" << endl;}
Student(int myno, char myname[], int mygrade) : Person(myno, myname), grade(mygrade)
{ }
void career() { cout << "I am student" << endl; }
};
class Teacher : public Person {
public:
int salary;
void teach() { cout << "I am teaching" << endl; }
Teacher(int myno, char myname[], int mysalary) : Person(myno, myname)
{ salary = mysalary; }
void career() { cout << "I am teacher" << endl; }
};
int main()
{
int choice;
Person *p;
// Person lisi(12, "lisi");
Student zhangsan(19, "zhangsan", 99);
Teacher yangzhu(133, "yangzhu", 7000);
printf("请输入你的选择: 1. 指向学生 2.指向老师 ");
scanf("%d", &choice);
if (choice == 2)
p = &yangzhu;
else
p = &zhangsan;
p->career();//系统会根据指针的基类型来决定调用哪一个同名方法
//系统会根据对象的类型来调用不同的同名方法
// lisi.career();
// zhangsan.career();
// yangzhu.career();
return 0;
}
//虚析构函数
#include <iostream>
#include <cstring>
using namespace std;
class Person {
private:
char name[20];
public:
Person(int myno, const char myname[]) { no = myno; strcpy(name, myname); }
int no;
void whoami() { cout << "I am " << name << endl; }
virtual ~Person() { cout << "destruct Person" << endl; }
};
class Student : public Person {
public:
char *nickname;
int grade;
void study() { cout << "I am studing" << endl;}
Student(int myno, char myname[], int mygrade, char mynickname[]) : Person(myno, myname)
{ grade = mygrade; nickname = (char *)malloc(strlen(mynickname)+1);
strcpy(nickname, mynickname); }
~Student() { cout << "destruct Student" << endl; free(nickname); }
};
int main()
{
Person *p;
p = new Student(19, "zhangsan", 99, "xiaogou");
p->whoami();
delete p;
return 0;
}
//纯虚函数在类库中的应用
#include <iostream>
#include <cstring>
using namespace std;
class Person { // 类库编写者实现Person类
private:
char name[20];
public:
Person(int myno, const char myname[]) { no = myno; strcpy(name, myname); }
int no;
void whoami() { cout << "I am " << name << endl; }
virtual void career() = 0;
void selfintro() { whoami(); career(); }
};
class Student : public Person { // 应用程序员实现覆盖虚函数career
public:
int grade;
void study() { cout << "I am studing" << endl;}
Student(int myno, char myname[], int mygrade) : Person(myno, myname), grade(mygrade)
{ }
void career() { cout << "I am student" << endl; }
};
class Teacher : public Person {
public:
int salary;
void teach() { cout << "I am teaching" << endl; }
Teacher(int myno, char myname[], int mysalary) : Person(myno, myname)
{ salary = mysalary; }
void career() { cout << "I am teacher" << endl; }
};
int main()
{
Student zhangsan(19, "zhangsan", 99);
Teacher yangzhu(133, "yangzhu", 7000);
//不同对象调用selfintro效果不一样
zhangsan.selfintro();
yangzhu.selfintro();
return 0;
}
//基本运算符重载
#include <iostream>
#include <cmath>
using namespace std;
class complex {
private:
double real, imag;
public:
/*
complex(double r, double i): real(r), imag(i) { }
complex(): real(0), imag(0) { }
complex(double r): real(r), imag(0) { } //explicit complex(double r): real(r), imag(0) { }
*/
complex(double r = 0, double i = 0): real(r), imag(i) { }
explicit operator double() { return sqrt(real * real + imag * imag); } // vc6 has no double operator, but dev c++ did
friend complex operator+(const complex &a, const complex &b) { return complex(a.real + b.real, a.imag + b.imag); }
//friend complex operator+(const complex &a, const complex &b) { complex sum = a; sum += b; return sum; }
friend complex operator-(const complex &a, const complex &b) { return complex(a.real - b.real, a.imag - b.imag); }
friend ostream& operator<<(ostream& os, const complex& b) {
os << b.real;
if (b.imag >= 0)
os << "+";
os << b.imag << "i";
return os;
}
complex& operator+=(const complex& b) { real += b.real; imag += b.imag; return *this; }
complex operator-() { return complex(-real, -imag); }
complex operator+() { return *this; }
complex& operator++() { real++; imag++; return *this;}
complex& operator--() { real--; imag--; return *this;}
complex operator++(int) { complex tmp = *this; real++; imag++; return tmp; } //Todo: 如何让函数返回右值
complex operator--(int) { complex tmp = *this; real--; imag--; return tmp; } //Todo: 如何让函数返回右值
friend bool operator==(const complex& a, const complex& b) { return a.real == b.real && a.imag == b.imag; }
friend bool operator!=(const complex& a, const complex& b) { return !(a == b); }
double operator[](int loc) { return loc == 0 ? real : imag; }
double operator()(char loc) { return loc == 'r' ? real : imag; }
};
int main()
{
complex zhangsan(-10, -10), lisi(3, 4);
complex yangzhu;
double result;
yangzhu = zhangsan + lisi;
cout << yangzhu << endl;
yangzhu += zhangsan;
cout << yangzhu << endl;
yangzhu = -yangzhu;
cout << yangzhu << endl;
zhangsan = yangzhu++;
cout << yangzhu << " " << zhangsan << endl;
zhangsan = ++yangzhu;
cout << yangzhu << " " << zhangsan << endl;
if (yangzhu == zhangsan)
cout << "equal" << endl;
else
cout << "not equal" << endl;
yangzhu = zhangsan + 10.1;
cout << yangzhu << endl;
result = double(lisi);
cout << result << endl;
cout << lisi[0] << " " << lisi[1] << endl;
cout << lisi('r') << " " << lisi('i') << endl;
return 0;
}
评论