如果你想要学习哪部分知识只需要取消那部分的注释再运行
#include <iostream>
#include <cstring>
using namespace std;
//结构体补充
// 结构体是一个数据类型,里面含有不同类型数据。
// 例如:
// struct Student
// {
// int ID;
// string name;
// void Print(int x,int y)
// {
// if(x=2,y=3)
// {
// cout<<"这是个结构体的成员函数1"<<endl;//endl会换行
// cout<<"这是个结构体的成员函数2";
// cout<<"这是个结构体的成员函数3"<<endl;
// }
// }
// int age;
// int score;
// };
// int main()
// {
// Student Bill;//定义了一个学生叫Bill,他的类型是Student,本质是个结构体,是个容器
// Bill.Print(2,3);//调用结构体的成员函数
// Bill.age=19;//当成元素使用
// cout<<"Bill's age is "<<Bill.age<<endl;
// return 0;
// }
// 类的声明
// class Student
// {
// int ID;
// string name;
// void Print(int x,int y)
// {
// if(x=2,y=3)
// {
// cout<<"这是个类的成员函数1"<<endl;//endl会换行
// cout<<"这是个类的成员函数2";
// cout<<"这是个类的成员函数3"<<endl;
// }
// }
// int age;
// int score;
// };
// int main()
// {
// Student Bill;//定义了一个学生叫Bill,他的类型是Student,本质是个类,是个容器
// Bill.Print(2,3);
// Bill.age=19;
// cout<<"Bill's age is "<<Bill.age<<endl;//上三行编译错误因为类里面的元素默认私有,结构体元素默认公有
// return 0;
// }
// class Student
// {
// private:
// public:
// int ID;
// string name;
// void Print(int x,int y)
// {
// if(x=2,y=3)
// {
// cout<<"这是个类的成员函数1"<<endl;//endl会换行
// cout<<"这是个类的成员函数2";
// cout<<"这是个类的成员函数3"<<endl;
// }
// }
// int age;
// int score;
// };
// int main()
// {
// Student Bill;//定义了一个学生叫Bill,他的类型是Student,本质是个类,是个容器
// Bill.Print(2,3);
// Bill.age=19;
// cout<<"Bill's age is "<<Bill.age<<endl;//因为表明了public
// return 0;
// }
// class apple
// {
// private:
// int apple1,apple2;
// public:
// int addapple(int x,int y)//类的外部接口,外面数值输入进入小括号里
// {
// apple1=x;
// apple2=y;
// return (apple1+apple2);
// }
// };//结构体结尾加;
// int main()
// {
// apple A;
// cout<<A.addapple(4,6)<<endl;//用公共的成员函数来访问私有的数据
// return 0;
// }
// 成员函数的定义
//一、定义普通成员函数,在类外定义
// class apple
// {
// private:
// int apple1,apple2;
// public:
// int addapple(int,int);//类内定义函数原型,不需要参数表,只需参数表的类型
// };
// int apple::addapple(int x,int y)
// {
// apple1=x;
// apple2=y;
// return (apple1+apple2);
// }
// int main()
// {
// apple A;
// cout<<A.addapple(4,6)<<endl;
// return 0;
// }
//二、普通的定义在类的内部,代码上二,提高运行效率,但是让类长度增加,所以建议只用在简短的函数
//三、类外定义,但是使用inline显式说明这是个内联函数
// class apple
// {
// private:
// int apple1,apple2;
// public:
// inline int addapple(int,int);//类内定义函数原型,不需要参数表,只需参数表的类型
// };
// inline int apple::addapple(int x,int y)
// {
// apple1=x;
// apple2=y;
// return (apple1+apple2);
// }
// int main()
// {
// apple A;
// cout<<A.addapple(4,6)<<endl;
// return 0;
// }
//对象定义使用
// class apple
// {
// private:
// int apple1,apple2;
// public:
// inline int addapple(int,int);
// }A1,A2;//定义对象的特殊方法,简单方法是直接在其他地方定义
//访问成员函数 对象名:成员函数名(实参表) 可以看出,实参表就是调用函数的时候输入的值
//指向对象的指针访问类内成员
// class apple
// {
// private:
// int apple1,apple2;
// public:
// inline int addapple(int,int);//类内定义函数原型,不需要参数表,只需参数表的类型
// };
// inline int apple::addapple(int x,int y)
// {
// apple1=x;
// apple2=y;
// return (apple1+apple2);
// }
// int main()
// {
// apple A;
// apple *ptr;//指向对象A的指针
// ptr=&A;
// cout<<A.addapple(4,6)<<endl;
// cout<<ptr->addapple(3,3)<<endl;//ptr调用成员函数的时候采用的是->,对象调用成员函数采用的是.
// cout<<(*ptr).addapple(3,4)<<endl;//*prt调用成员函数采用.
// return 0;
// }
//构造函数和析构函数
//c++利用构造函数为对象初始化(为成员赋值),在创建对象的同时调用,省去了主函数等地方调用成员函数的步骤
//特性:1.名字必须与类名相同2.可以有参数,但不能有返回值3.不需要用户调用,创建对象即调用
// class machine{
// private:
// int head,hand;
// public:
// machine(int a,int b)//构造函数,没有返回值,连void也没有
// {
// head=a;
// hand=b;
// cout<<"构造函数被调用"<<endl;
// }
// void addfigure()
// {
// cout<<(head+hand)<<endl;
// }
// };
// int main()
// {
// machine A1(2,3);//创建的同时就调用了构造函数
// A1.addfigure();
// return 0;
// }
//建立对象的时候赋初值的两种方法
// 一、类名 对象名(实参表)
// machine A1(2,3);
// 二、类名*指针变量名=new 类名(实参表)
// machine*P1=new machine(2,3);
// P1->addfigure();
// delete P1;//使用完记得释放
//构造函数可以在类外定义,但是不需要返回值,连void也没有
// 对比:
// 类内:
// int one,two;
// gouzao(int,int);
// int putong(int);
// 类外:
// gouzao::gouzao(int a,int b)
// {
// one=a;
// two=b;
// }
// int gouzao::putong(a)
// {
// one=a;
// return one;
// }
//用成员初始化列表对数据成员初始化(只能应用于构造函数)
// class lei
// {
// int Q1,Q2;
// int W2;
// public:
// lei (int i,int j):Q1(i),Q2(j)//成员初始化列表
// { cout<<"Q1 Q2is"<<Q1<<Q2<<endl;}
// // int st(int i2):W2(i2)
// // {
// // return (W2);
// // }
// };
// int main()
// {
// lei A(2,3);
// // cout<<(A.st(3))<<endl;//成员初始化列表只能应用于构造函数
// return 0;
// }
//重载构造函数
// class student{
// private:
// int hair,jump,run;
// public:
// student();
// student(int,int,int);//重载函数类内声明可省略形参
// void figure();
// };
// student::student()
// {
// hair=168;
// jump=120;
// run=3;
// }
// student::student(int a,int b,int c)
// {
// hair=a;
// jump=b;
// run=c;
// }
// inline void student::figure()
// {
// cout<<hair<<jump<<run<<endl;
// }
// int main()
// {
// student A1;
// student A2(100,100,100);
// A1.figure();
// A2.figure();
// return 0;
// }
// 带默认函数的构造参数
//平时的stu::stu()就是默认构造函数,指定实参也可以是默认构造函数,所以一个类只有一个
// class stu{
// private:
// int a,b;
// public:
// stu(int i=1,int j=2)//直接在括号里面给形参赋值
// {
// a=i;
// b=j;
// }
// void addd()
// {
// cout<<(a+b)<<endl;
// }
// };
// int main()
// {
// stu A;
// A.addd();
// return 0;
// }
// 析构函数
// 释放分配给对象的内存
// class stu{
// private:
// int a,b;
// public:
// stu(int i=1,int j=2)//直接在括号里面给形参赋值
// {
// a=1;
// b=2;
// }
// void addd()
// {
// cout<<(a+b)<<endl;
// }
// ~stu()
// {
// cout<<"析构函数已被调用"<<endl;
// }
// };
// int main()
// {
// stu A;
// A.addd();
// return 0;
// }
个人笔记,如果有错误请指出