1. 动态分配内存new和delete
-
动态分配出来的内存没有变量名，只能通过指向它的指针来操作内存中的数据。
-
如果动态分配的内存使用完毕，必须用delete释放，否则有可能用尽系统的内存。
-
动态分配的内存生命周期与程序相同，程序退出时，系统会自动回收。
-
就算指针的作用域已经失效，所指向的内存也不会释放。
int main() { int* p = new int(5); cout << "*p= " << *p << endl; *p = 40; cout << "*P= " << *p << endl; delete p; // 释放分配的内存 return 0; }
2. 二级指针
-
二级指针用于存放指针变量的地址。
-
声明二级指针的语法：数据类型 **指针名
-
使用指针有两个目的：1）传递地址；2）存放动态分配的内存地址。
int main()
{
int i = 8;
cout << "i = " << i << ", i 的地址为： " << &i << endl;
int* p = &i;
cout << "p = " << p << ", p 的地址为： " << &p << ", *p = " << *p << endl;
int** pp = &p;
cout << "pp= " << pp << ", pp 的地址为： " << &pp << ", *pp= " << *pp << endl;
return 0;
}
3. C++的对象模型（重点）
- 空类的大小为1.
- 类的成员函数不占用类的大小，静态成员变量不占用类的大小，静态成员函数不占用类的大小。
- 普通成员变量占用类的大小。
4. This 指针
-
每个对象都有一个隐藏的this指针，但不属于对象，是编译器添加的
-
编译器会把this指针传入成员函数内
-
class Maker { public: Maker() { a = 10; b = 20; } void func() { cout << "a = " << this->a << ", b = " << this->b << endl; } public: int a; int b; }; void test01() { Maker a; a.func(); } int main() { test01(); return 0; }
5. 常函数和常对象
5.1 常函数：
-
在函数（）后面加上 const，这个函数就是常函数；
-
常函数内不能修改普通成员变量；
-
mutable修饰的成员变量，在常函数中可以被修改；
-
class Maker { public: Maker(int id, int age) { this->id = id; this->age = age; score = 100; } // 常函数再函数名括号后加const void printMaker() const { // id = 20; 常函数内不能修改普通的成员变量 score = 200; // mutable 修饰的成员变量，可以在常函数中被修改 cout << "score is: " << score << endl; } public: int id; int age; mutable int score; };
5.2 常对象
-
在对象前加上const 使其成为常对象；
-
常对象不能改变成员变量的值；
-
常对象不能调用普通成员函数；
-
常对象可以调用常函数；
-
常对象可以修改mutable 修饰的成员;
-
#include<iostream> using namespace std; class Maker { public: Maker(int id, int age) { this->id = id; this->age = age; score = 100; } // 常函数再函数名括号后加const void printMaker() const { // id = 20; 常函数内不能修改普通的成员变量 score = 200; // mutable 修饰的成员变量，可以在常函数中被修改 cout << "score is: " << score << endl; } void func() { cout << "this is func!" << endl; } public: int id; int age; mutable int score; }; void test() { const Maker a(1, 10); // 创建一个常对象 // a.id = 20; // 常对象不能够修改成员变量的值 // a.func(); // 常对象不能调用普通成员函数 a.printMaker(); // 常对象可以调用常函数 a.score = 500; // 常对象可以修改mutable 修饰的成员变量 } int main() { test(); return 0; }
6. 单例模式
- 单例模式就是一个类只能实例化出一个对象；
7.继承
-
继承的好处：可以减少重复的代码
-
class A : public B;
A类称为子类或派生类，B类称为父类或基类。
# include <iostream> using namespace std; // 继承实现页面 // 公共显示页面 class BasePage { public: void header() { cout << "首页，公开课，登录，注册。。。 （公共头部）" << endl; } void footer() { cout << "帮助中心，交流合作，站内地图，，，，（公共底部）" << endl; } void left() { cout << "Java,Python,C++...(公共分类列表)" << endl; } }; //java class java :public BasePage { public: void content() { cout << "java 视频教程。"<<endl; } }; //python class python :public BasePage { public: void content() { cout << "pyhton 视频教程。"<<endl; } }; //C++ class cpp :public BasePage { public: void content() { cout << "C++ 视频教程。"<<endl; } }; void test02() { cout << "JAVA视频下载页面如下：" << endl; java ja; ja.header(); ja.footer(); ja.left(); ja.content(); cout << "========================" << endl; cout << "Python视频下载页面如下：" << endl; python py; py.header(); py.footer(); py.left(); py.content(); cout << "========================" << endl; cout << "C++视频下载页面如下：" << endl; cpp cp; cp.header(); cp.footer(); cp.left(); cp.content(); cout << "========================" << endl; } int main() { test02(); return 0; }
8. 继承方式
-
公共继承
-
保护继承
-
私有继承
继承过程的构造和析构顺序：
#include<iostream>
using namespace std;
class Base
{
public:
Base()
{
cout << "这是父类构造函数。" << endl;
}
~Base()
{
cout << "这是父类析构函数。" << endl;
}
};
class Son: public Base
{
public:
Son()
{
cout << "这是子类构造函数。" << endl;
}
~Son()
{
cout << "这是子类析构函数。" << endl;
}
};
void test03() // 继承中的构造和析构顺序
{
// Base b1;
Son s1; // 先构造父类，再构造子类，析构的顺序和构造的顺序相反
}
int main()
{
test03();
return 0;
}
继承同名成员处理方式
当子类和父类出现同名成员：
-
访问子类同名成员，直接访问即可
-
访问父类同名成员 ，需要加作用域
#include<iostream> using namespace std; class Base { public: Base() { m_A = 100; } int m_A; }; class Son :public Base { public: Son() { m_A = 200; } int m_A; }; void test05() { Son s1; cout << "子类中的m_A:" << s1.m_A << endl; // 通过子类对象访问父类中的同名成员，需要加上作用域 cout << "父类中的m_A:" << s1.Base::m_A << endl; } int main() { test05(); return 0; } -
当子类与父类有同名的成员函数，子类会隐藏父类中的成员函数，加作用域可以访问父类中的成员函数。
9.菱形继承
菱形继承概念：
两个派生类继承同一个基类
又有某个类同时继承这两个派生类
这种继承称为菱形继承。
10.多态
多态的基本概念：
多态使是C++面向对象的三大特性之一
多态分为两类：
- 静态多态：函数重载和运算符重载属于静态多态，服复用函数名
- 动态多态：派生类和虚函数实现运行时多态
静态多态和动态多态区别：
- 静态多态的函数地址早绑定——编译阶段确定函数地址
- 动态多态的函数地址晚绑定——运行阶段确定函数地址
#include<iostream>
using namespace std;
// 多态
// 动物类
class Animal
{
public:
// 虚函数
virtual void speak()
{
cout << "动物在说话" << endl;
}
};
// 猫类
class Cat :public Animal
{
public:
void speak()
// 重写：函数返回值类型，函数名，参数列表完全相同
{
cout << "小猫在说话" << endl;
}
};
// 狗类
class Dog :public Animal
{
public:
void speak()
{
cout << "小狗在说话" << endl;
}
};
// 执行说话函数
// 地址早绑定，在编译阶段确定函数的地址
// 如果执行让猫说话，那么这个函数地址就不能提前绑定
// 需要在运行阶段进行绑定，即地址晚绑定
// 动态多态满足条件：
// 1、有继承关系
// 2、子类重写父类的虚函数
void doSpeak(Animal &animal) //Animal &animal = cat;
{
animal.speak();
}
void test01()
{
Cat cat;
doSpeak(cat);
Dog dog;
doSpeak(dog);
}
int main()
{
test01();
return 0;
}
扫一扫
7421
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
