C++入门

m0_46521579

已于 2022-10-07 21:37:16 修改

阅读量1k

点赞数 3

分类专栏： qt 文章标签： c++ qt 开发语言

于 2022-10-07 20:29:51 首次发布

本文链接：https://blog.csdn.net/m0_46521579/article/details/127198288

版权

qt 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

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;
}