C++速成笔记

C++速成笔记

硬核注释，建议耐心看完。

1. 类和方法

#include <iostream>     //包含了cin、cout、endl等输入输出流函数的头文件
using namespace std;   //using语句，用于区分不同类当中的变量或者方法。std带有cin、cout等常用函数

class student  //定义类，有点类似于结构体
{
public:     //啥都不写默认为private，私有变量在其他类当中是无法访问的。
	int age;  //在正规的写法中，属性是写在private里面的，只有方法是写在public里面的。
	string name;
	static int count();  //定义静态方法。
	static int cnt;  //定义静态成员变量，可以视为类自己的属性，非static是对象的属性，需要注意在主函数之外进行初始化。
	void eat() const;  //常成员函数，只能读调用，不能被修改，注意const位置。
	student();  //默认构造函数
	student(int a, string n);  //赋值构造函数
	~student();  //析构函数，用法类似于free()释放类所占用的内存，小程序可以不写，程序执行完自动执行。
};

int student::cnt = 0;  //静态变量的初始化。

student::student(int a, string n)  //函数实现部分
{
	age = a;
	name = n;
}

student::student()
{
	age = 100;
	name = "张三奶奶";
}

student::~student()
{
	cout << "删除成功" << endl;
}

int student::count()  //注意有返回值方法的书写方式，先写返回类型，再写属于哪个类
{
	return cnt;
}

void student::eat() const  //常函数实现
{
	cout << "在吃饭" << endl;
}

int main()
{
	student a;
	student b(18, "张三");
	cout << a.age <<"岁的" << a.name;
	a.eat();
	cout << b.age << "岁的" << b.name ;
	b.eat();
	cout << "这个类被调用了" << student::count() << "次" << endl;

	return 0;
}

2. 继承与public、private和protect

/*接上一段代码*/
class undergraduate : public student  
//继承的书写方式，此处是将public内所有定义的内容继承到子类，private和protect算是同级，且对于其他类来说功能相同都不能访问。
//但是在继承当中就有区别了，子类可以继承protect里定义的内容，但不能继承private中的。
{  
public:
	string course;
	undergraduate();
	undergraduate(int a,string n,string c);
};

undergraduate::undergraduate() :student() //子类构造函数的写法。
//注意，如果写了默认构造函数调用子类对象的时候仍然是先调用父类的默认构造函数，在调用子类的默认构造函数。
{
	course = "java";
}

undergraduate::undergraduate(int a, string n, string c) :student(a, n)  //注意事项同上
{
	course = c;
}

int main()
{
	student a;
	student b(18, "张三");
	undergraduate c;
	cout << c.age << "岁的" << c.name;  //子类不能继承父类的构造函数，但是在创建对象的时候自动调用父类的默认构造函数。
	c.eat();
	cout << a.age <<"岁的" << a.name;
	a.eat();
	cout << b.age << "岁的" << b.name ;
	b.eat();
	cout << "这个类被调用了" << student::count() << "次" << endl;

	return 0;
}

3. 多态

//1.重载：函数名相同，参数不同。
//2.隐藏：在继承中子类可以创建和父类一摸一样（也可不同）的方法，在使用子类对象时编译器自动隐藏父类同样的方法。
//3.覆盖（实现多态）：使用虚函数（在java中叫抽象函数）virtual在父类和子类中定义函数，从而使本来只能指向公共部分的父类指针，指向相同的虚函数，以此达到多态。
//接上代码
class student()
{
	virtual void study();
}
class undergraduate():student()
{
	virtual void study();
}
void student::study(bool a)
{
	cout << "好好学习" << endl;
}
void undergraduate::study(bool a)
{
	cout << "好好coding" << endl;
}

int main()
{
	student a;
	undergraduate c;
	student* p; 
	a.study(true);
	c.study(true);
	p=&a;
	p->study();
	p=&c;  //原本父类指针是无法指向子类独有部分的，不懂的先看下面
	p->studt();
}

4. 类指针

int main()
{
    //不考虑继承的状态下
	student* e = &a;
	cout << e->age << "岁的" << e->name;
	e->eat();
	
    student* f = new student(99,"孙七");  //高级写法
    cout << f->age << "岁的" << f->name;
	f->eat();
	delete f;  //相当于free()，手动调用析构函数
  
  //考虑继承的状态下
  student* pp;
  undergraduate* cc;
  student p;
  undergraduate c;
  pp=&p;
  cc=&c;
  pp=&c;  //父类指针可以指向父子类共有部分
  cc=&p;  //这句会报错，子类的指针不能指向父类
}

5. 抽象类

class student
{
public:
	student();
	~student();
	virtual void study() =0;  
//抽象类也需要构造函数和析构函数，定义函数时不能少了=0，
//这表明study()方法是个纯虚函数，是不需要实现的，需要在子类的定义中进行实现。	
//注意：抽象类在主函数中不能被定义对象，但是可以定义指针。student a （x）student* p（√）
}

student::student()
{
	name ="张三";
}

student::~student()
{
	cout << "删除成功" << endl;
}

class undergraduate : public student
{
public:
	string course;
	virtual void study();
	undergraduate();
};

undergraduate::undergraduate() :student()
{
	course = "C++";
}

void undergraduate::study()
{
	cout << "好好coding" << endl;
}

class graduate : public student
{
public:
	string course;
	virtual void study();
	graduate();
};

graduate::graduate() :student()
{
	course = "java";
}

void graduate::study()
{
	cout << "好好挣钱" << endl;
}

int main()
{
	student* p;
	undergraduate a;
	graduate b;
	p = &a;
	p->study();
	p = &b;
	p->study();
}

大致介绍了C++的核心内容，应付考试什么的应该够了。
如有问题，多多指教。