1. C++
C++是C语言的升级版，在C的基础上增加了很多功能，是一种高级语言。
C语言是面向过程的，C++是面向对象的。
2. C++的类
C++的类是C语言结构体的升级版。类的成员不仅可以是变量也可以是函数。
class student
{
public:
char name[64];
char age;
}
3. 对象
对象是类的实例化。
#include <iostream>
using namespace std;
class student
{
public:
char name[64];
char age;
};
int main()
{
student my; //直接定义对象
student *your = new student; //在堆里定义对象
delete your; //删除对象
return 0;
}
student是类，my是对象。
访问类的成员
#include <iostream>
using namespace std;
class student
{
public:
char name[64];
int age;
};
int main()
{
student my; //直接定义对象
student *your = new student; //在堆里定义对象
my.age = 18;
your->age = 19;
cout << my.age << endl;
cout << your->age << endl;
delete your; //删除对象
return 0;
}
普通变量通过点来访问，指针通过->来访问。
类的函数成员
#include <iostream>
using namespace std;
class student
{
public:
char name[64];
int age;
/* 在类里面定义函数 */
void test()
{
cout << "test()" << endl;
};
/* 在类内声明函数，在类外或类内实现函数 */
void test2();
};
void student::test2()
{
cout << "test2()" << endl;
}
int main()
{
student my; //直接定义对象
student *your = new student; //在堆里定义对象
my.age = 18;
your->age = 19;
my.test();
cout << my.age << endl;
cout << your->age << endl;
your->test2();
delete your; //删除对象
return 0;
}
类的访问修饰符
类的访问修饰符就是对类的成员进行权限管理。
public：表示函数和变量是公开的，任何人都可以访问。
private：表示函数和变量只能在自己的类里面自己访问自己，不能通过对象来访问。
? ? ? ? ? ? ? ? 可以通过函数对其进行修改和访问。
#include <iostream>
using namespace std;
class student
{
public:
char name[64];
int age;
/* 在类里面定义函数 */
void test()
{
cout << "test()" << endl;
};
/* 在类内声明函数，在类外或类内实现函数 */
void test2();
void set_gender(int data)
{
gender = data;
}
void print_gender();
private:
int gender;
};
void student::test2()
{
cout << "test2()" << endl;
}
void student::print_gender()
{
if(gender == 0)
{
cout << "gender: female" << endl;
}
else if(gender == 1)
{
cout << "gender: male" << endl;
}
else
{
cout << "error" << endl;
}
}
int main()
{
student my; //直接定义对象
student *your = new student; //在堆里定义对象
my.age = 18;
my.set_gender(1);
your->age = 19;
your->set_gender(2);
my.test();
cout << my.age << endl;
my.print_gender();
cout << your->age << endl;
your->print_gender();
your->test2();
delete your; //删除对象
return 0;
}
protected：表示函数和变量只能在自己的类里面自己访问自己，但是可以被派生类来访问的。
4. 类函数的重载特性
类函数的重载特性就是说我们可以在类里面定义同名的函数，但是参数不同的函数。
重载函数在调用的时候，会根据参数的类型，然后去匹配相应的函数进行调用。
#include <iostream>
using namespace std;
class student
{
public:
char name[64];
int age;
/* 在类里面定义函数 */
void test()
{
cout << "test()" << endl;
};
/* 类函数的重载特性 */
void test(int a)
{
cout << "test(" << a << ")" << endl;
};
/* 在类内声明函数，在类外或类内实现函数 */
void test2();
void set_gender(int data)
{
gender = data;
}
void print_gender();
private:
int gender;
};
void student::test2()
{
cout << "test2()" << endl;
}
void student::print_gender()
{
if(gender == 0)
{
cout << "gender: female" << endl;
}
else if(gender == 1)
{
cout << "gender: male" << endl;
}
else
{
cout << "error" << endl;
}
}
int main()
{
student my; //直接定义对象
student *your = new student; //在堆里定义对象
my.age = 18;
my.set_gender(1);
your->age = 19;
your->set_gender(2);
my.test();
cout << my.age << endl;
my.print_gender();
cout << your->age << endl;
your->print_gender();
your->test2();
my.test(12);
your->test(20221007);
delete your; //删除对象
return 0;
}
5. 构造函数和析构函数
析构函数：假如我们定义了析构函数，当对象被删除或者生命周期结束的时候，就会触发析构函数。
构造函数：假如我们定义了类，就会触发这个构造函数。
如何定义构造函数和析构函数？
（1）构造函数和析构函数的名字必须和类名一摸一样
（2）析构函数要在前面加上一个~
构造函数可以被重载，析构函数不能被重载
#include <iostream>
using namespace std;
class student
{
public:
/* 构造函数，在对象被创建时被触发 */
student();
/* 析构函数，在对象生命周期结束时触发*/
~student();
char name[64];
int age;
/* 在类里面定义函数 */
void test()
{
cout << "test()" << endl;
};
/* 类函数的重载特性 */
void test(int a)
{
cout << "test(" << a << ")" << endl;
};
/* 在类内声明函数，在类外或类内实现函数 */
void test2();
void set_gender(int data)
{
gender = data;
}
void print_gender();
private:
int gender;
};
student::student()
{
cout << "Hello,world" << endl;
}
student::~student()
{
cout << "Bye, world" << endl;
}
void student::test2()
{
cout << "test2()" << endl;
}
void student::print_gender()
{
if(gender == 0)
{
cout << "gender: female" << endl;
}
else if(gender == 1)
{
cout << "gender: male" << endl;
}
else
{
cout << "error" << endl;
}
}
int main()
{
student my; //直接定义对象
student *your = new student; //在堆里定义对象
my.age = 18;
my.set_gender(1);
your->age = 19;
your->set_gender(2);
my.test();
cout << my.age << endl;
my.print_gender();
cout << your->age << endl;
your->print_gender();
your->test2();
my.test(12);
your->test(20221007);
delete your; //删除对象
return 0;
}
6. 类的继承
类的继承允许我们在新的类里面继承父类的public还有protected部分，private是不能被继承的。
当我们觉得这个类不好的时候，可以使用类的继承，添加我们需要的功能。
格式：
class 儿子：public 爸爸{
public:
protected:
}
如何在子类里面访问父类的成员？
通过.和->来访问
#include <iostream>
using namespace std;
class student
{
public:
/* 构造函数，在对象被创建时被触发 */
student();
/* 析构函数，在对象生命周期结束时触发*/
~student();
char name[64];
int age;
/* 在类里面定义函数 */
void test()
{
cout << "test()" << endl;
};
/* 类函数的重载特性 */
void test(int a)
{
cout << "test(" << a << ")" << endl;
};
/* 在类内声明函数，在类外或类内实现函数 */
void test2();
void set_gender(int data)
{
gender = data;
}
void print_gender();
private:
int gender;
};
student::student()
{
cout << "Hello,world" << endl;
}
student::~student()
{
cout << "Bye, world" << endl;
}
void student::test2()
{
cout << "test2()" << endl;
}
void student::print_gender()
{
if(gender == 0)
{
cout << "gender: female" << endl;
}
else if(gender == 1)
{
cout << "gender: male" << endl;
}
else
{
cout << "error" << endl;
}
}
/* 类的继承 */
class mystudent:public student
{
public:
int grade;
};
int main()
{
student my; //直接定义对象
student *your = new student; //在堆里定义对象
mystudent mystu;
my.age = 18;
my.set_gender(1);
your->age = 19;
your->set_gender(2);
my.test();
cout << my.age << endl;
my.print_gender();
cout << your->age << endl;
your->print_gender();
your->test2();
my.test(12);
your->test(20221007);
mystu.grade = 100;
mystu.age = 23;
cout << "mystu.grade = " << mystu.grade << endl;
cout << "mystu.age = " << mystu.age << endl;
delete your; //删除对象
return 0;
}
7. 虚函数与纯虚函数
虚函数：有实际定义的，允许派生类对他进行覆盖式的替换，用virtual来修饰，用在类的继承上。
纯虚函数：没有实际定义的虚函数就是纯虚函数。
虚函数的优点？
可以预留接口，实现分工合作。
#include <iostream>
using namespace std;
class student
{
public:
/* 构造函数，在对象被创建时被触发 */
student();
/* 析构函数，在对象生命周期结束时触发*/
~student();
char name[64];
int age;
/* 在类里面定义函数 */
void test()
{
cout << "test()" << endl;
};
/* 类函数的重载特性 */
void test(int a)
{
cout << "test(" << a << ")" << endl;
};
/* 在类内声明函数，在类外或类内实现函数 */
void test2();
void set_gender(int data)
{
gender = data;
}
void print_gender();
virtual void test_vir(); //虚函数
virtual void test_vir_a(){}; //纯虚函数
private:
int gender;
};
student::student()
{
cout << "Hello,world" << endl;
}
student::~student()
{
cout << "Bye, world" << endl;
}
void student::test2()
{
cout << "test2()" << endl;
}
void student::test_vir()
{
cout << "test_vir()" << endl;
}
void student::print_gender()
{
if(gender == 0)
{
cout << "gender: female" << endl;
}
else if(gender == 1)
{
cout << "gender: male" << endl;
}
else
{
cout << "error" << endl;
}
}
/* 类的继承 */
class mystudent:public student
{
public:
int grade;
void test_vir()
{
cout << "mystudent::test_vir()" << endl;
}
};
int main()
{
mystudent mystu;
mystu.test_vir();
return 0;
}
|