1 .const
#include <stdlib.h>
#include<stdio.h>
#include<iostream>
using namespace std;
class Student {
private:
string name;
int age;
public:
int grade;
public:
Student(string name, int age) :name(name), age(age) {
};
void printName() const {
//1.函数后面加const 用来限制this 关键字不能对类的属性进行修改
this->grade = 19;//编译不通过
this->age = 14;//编译不通过
cout << this->name << endl;
};
void printAge() {
cout << this->age << endl;
}
};
void main() {
const Student stu("Jack", 18);
stu.printName();
cout << stu.grade << endl;
//2.const 修饰的对象 只能调const函数
stu.printAge(); //编译不通过
}
总结：
1.const int* p ：常量指针，即指针指向的值是为常量，不能进行修改。但可以对地址进行修改
int num = 3;
int num2 = 5;
const int* p = #
//常量指针，不能对值修改
*p = 18; //编译不通过
//可以修改地址
p = &num2;
2.int* const p : 指针常量,可以修改指针所指向的值，但不能修改指针的地址
int num = 3;
int num2 = 5;
int* const p = #
//指针常量，可以修改值
*p = 18;
//不可以修改地址
p = &num2; // 编译不通过
3.函数后面加const 用来限制this 关键字不能对类的属性进行修改
//1.函数后面加const 用来限制this 关键字不能对类的属性进行修改
this->grade = 19;//编译不通过
this->age = 14;//编译不通过
4.const修饰的对象，只能调const修饰的函数
void main() {
const Student stu("Jack", 18);
stu.printName();
cout << stu.grade << endl;
//2.const 修饰的对象 只能调const函数
stu.printAge(); //编译不通过
2.继承
2.1类成员修饰符的访问权限
image.png
#include <stdlib.h>
#include<stdio.h>
#include<iostream>
using namespace std;
class Person {
private:
string name;
protected:
int age;
public:
int sex;
public:
void test() {
//本类可以访问所有成员类型
cout << name << age << sex<<endl;
}
};
class Student:public Person{
public:
void test(){
/*子类内可以方法public和protected修饰的变量，不能访问private的变量*/
cout << name << sex; //编译报错
cout << age << sex;
}
};
void main() {
Person p = Person();
//类外部只能访问public修饰的变量
p.sex = 1;
p.age; //编译报错
p.name;//编译报错
}
2.2 三种继承方式
image.png
- 当用public继承的时候，父类中的public成员会被继承到子类的public中去，父类的protected成员也会被继承到子类的protected中去
- 当用protected继承的时候，父类中无论是public和protected的成员都会被继承到子类的protected中去
- 当private继承的时候，父类中public和protected的成员都会被继承到子类的private中去
注意：父类的private成员 不管哪种继承方式都是不会被继承下来的
#include <stdlib.h>
#include<stdio.h>
#include<iostream>
using namespace std;
class Person {
private:
string name;
protected:
int age;
public:
int sex;
public:
void test() {
cout << name << age << sex<<endl;
}
};
class Student:private Person{
public:
void test(){
cout << age << endl;
}
};
void main() {
Student p = Student();
//private 继承后 基类中的public 变量在子类中是private 因此在类外不可访问
p.sex = 1; //编译失败
}
使用private继承后，基类指针不能指向派生类对象
image.png
3.友元类和友元函数
如果将类的封装比喻成一堵墙的话，那么友元机制就像墙上了开了一个门，那些得 到允许的类或函数允许通过这个门访问一般的类或者函数无法访问的私有属性和方法。友元机制使类的封装性得到消弱，所以使用时一定要慎重。
#include <stdlib.h>
#include<stdio.h>
#include<iostream>
using namespace std;
class Person {
private:
string name;
void printName() {
cout << "私有函数"<<name << endl;
}
protected:
int age;
public:
int sex;
public:
Person(string name, int age, int sex) :name(name), age(age), sex(sex) {
}
friend void test();
};
void test() {
Person p = Person("jack", 16, 1);
//可以在友元函数内访问私有变量
cout << p.name << endl;
//可以在友元函数内访问私有函数
p.printName();
}
void main() {
test();
}
友元类
#include <stdlib.h>
#include<stdio.h>
#include<iostream>
using namespace std;
class Person {
private:
string name="jack";
void printName() {
cout << "私有函数"<<name << endl;
}
friend class Student;
};
class Student {
public:
void test() {
Person p = Person();
//可以在友元类内访问私有变量
cout << p.name << endl;
//可以在友元类内调用私有函数
p.printName();
}
};
void main() {
Student s = Student();
s.test();
}
4.virtual的用法
1.在java中不可以使用多继承，但在C++中可以使用多继承，但要保证不能有二义性(歧义），虚继承可以防止二义性。
// 2.2 虚继承 （二义性）
class A{
public:
char* name;
};
class B : virtual public A{ // 确保继承过来的相同属性或者函数，只存在一份拷贝
};
class C :virtual public A{
};
class D : public B ,public C
{
};
2.多态
程序在编译期间不知晓程序运行的状态，只有在真正运行的过程中才会找到需要去执行的方法
class Activity {
public:
void onCreate() {
cout << "Activity中的onCreate方法" << endl;
}
};
class MainActiviy :public Activity {
void onCreate() {
cout << "MainActiviy中的onCreate方法" << endl;
}
};
void main() {
//基类指针指向派生类对象 如果不使用虚函数 则会直接调用基类中的方法
Activity* activity = new MainActiviy();
activity->onCreate();
}
***输出结果： "Activity中的onCreate方法"
class Activity {
public:
virtual void onCreate() {
cout << "Activity中的onCreate方法" << endl;
}
};
class MainActiviy :public Activity {
void onCreate() {
cout << "MainActiviy中的onCreate方法" << endl;
}
};
void main() {
//基类指针指向派生类对象 当使用了virtual函数后，程序会在运行期间去找真正的对象去调用方法
Activity* activity = new MainActiviy();
activity->onCreate();
}
输出结果："MainActiviy中的onCreate方法"
3.纯虚函数
// java 中类似的 抽象类，接口 纯虚函数
class BaseActivity // 跟 java 中的抽象类一个概念
{
public:
void onCreate(){// 普通函数
initView();
initData();
}
// 子类必须要实现
virtual void initData() = 0;// 虚函数，没有实现的，类似于 java 中的抽象方法，如果子类不实现会报错
virtual void initView() = 0;
};
// 如果不实现父类的纯虚函数，那么 MainActivity 也会变成抽象类，抽象类不允许实例化
class MainActivity : public BaseActivity
{
public:
void initData(){
cout << "initData" << endl;
}
void initView(){
cout << "initView" << endl;
}
};
void main(){
BaseActivity *m_a = new MainActivity();
m_a->onCreate();
getchar();
}
执行结果：
image.png
