类
#include <iostream>
class Course {
private:
std::string name;
public:
// 方式1 推荐
Course(std::string name) :name(name) {}
// 方式2
// Course(std::string name) {
// this->name = name;
// }
};
class People {
private:
std::string name;
int age = 0;
public:
People(std::string name, int age) :name(name), age(age) {}
};
class Student : public People{
private:
Course course;
public:
// 方式1 给对象course初始化
// Student(std::string name, int age, Course course1, std::string courseName) :People(name, age), course(course1) {}
// 方式2 给对象course初始化 构造函数
Student(std::string name, int age, Course course1, std::string courseName) :People(name, age), course(courseName) {}
};
int main() {
Course course("C++");
Student student("zhangSan", 23, course, "c++++++");
return 0;
}
构造函数
构造函数 方式1
#include <iostream>
class People {
public: // 构造函数
// 无参构造函数
People() {
std::cout << "空参构造函数" << std::endl;
}
// 一个参数 的 构造函数
// People(char * name) {
// this->name = name;
// }
// 等价于
// People(char * name) :name(name) {}
// 一个参数构造函数 先去调用两个参数的构造函数,再调用1个参数的构造函数
People(char * name) :People(name, 0){
std::cout << "1个参数沟通函数." << name << std::endl;
}
// 两个参数 的 构造函数
People(char * name, int age) :name(name), age(age) {
std::cout << "2个参数构造函数." << name << ", " << age << std::endl;
}
private: // 私有属性
char * name;
int age;
public: // get set
char * getName(){
return this->name;
}
int getAge() {
return this->age;
}
void setName(char * name) {
this->name = name;
}
void setAge(int age){
this->age = age;
}
};
int main() {
// 栈区
// 方式1
People people; // 空参构造函数
people.setName("zhangSan");
people.setAge(23);
std::cout<< people.getName() << ", " << people.getAge() << std::endl;
std::cout<< " ------------------ " << std::endl;
// 方式2
People people2("liSi", 24); // 2个参数构造函数
std::cout<< people2.getName() << ", " << people2.getAge() << std::endl;
std::cout<< " ------------------ " << std::endl;
// 方式3
People people3("wangWu"); // 1个参数的构造函数
std::cout<< " ------------------------------------ " << std::endl;
// 堆区
// 方式4
People * people4 = new People("liuLiu", 26);
std::cout<< people4->getName() << ", " << people4->getAge() << std::endl;
delete people4;
return 0;
}
// 结果打印:
//空参构造函数
//zhangSan, 23
// ------------------
//2个参数构造函数.liSi, 24
//liSi, 24
// ------------------
//2个参数构造函数.wangWu, 0
//1个参数沟通函数.wangWu
// ------------------------------------
//2个参数构造函数.liuLiu, 26
//liuLiu, 26
构造函数 方式2
CMakeLists.txt
People.h
#include <iostream>
class People {
public: // 构造函数
// 无参构造函数
People();
// 一个参数构造函数
People(char * name);
// 两个参数
People(char * name, int age);
private: // 私有属性
char * name;
int age;
public: // get set
char * getName();
int getAge();
void setName(char * name);
void setAge(int age);
};
People.cpp
#include "People.h"
People::People() {
std::cout << "empty parameter" << std::endl;
}
People::People(char *name) :People(name, 0){
this->name = name;
std::cout << "one parameter." << name << std::endl;
}
People::People(char *name, int age) {
this->name = name;
this->age = age;
std::cout << "two parameter." << name << ", " << age << std::endl;
}
char * People::getName(){
return this->name;
}
int People::getAge() {
return this->age;
}
void People::setName(char * name) {
this->name = name;
}
void People::setAge(int age){
this->age = age;
}
main.cpp
#include "People.h"
int main() {
// 栈区
// 方式1
People people; // 空参构造函数
people.setName("zhangSan");
people.setAge(23);
std::cout<< people.getName() << ", " << people.getAge() << std::endl;
std::cout<< " ------------------ " << std::endl;
// 方式2
People people2("liSi", 24); // 2个参数构造函数
std::cout<< people2.getName() << ", " << people2.getAge() << std::endl;
std::cout<< " ------------------ " << std::endl;
// 方式3
People people3("wangWu"); // 1个参数的构造函数
std::cout<< " ------------------------------------ " << std::endl;
// 堆区
// 方式4
People * people4 = new People("liuLiu", 26);
std::cout<< people4->getName() << ", " << people4->getAge() << std::endl;
delete people4;
people4 = NULL;
return 0;
}
//empty parameter
//zhangSan, 23
// ------------------
//two parameter.liSi, 24
//liSi, 24
// ------------------
//two parameter.wangWu, 0
//one parameter.wangWu
// ------------------------------------
//two parameter.liuLiu, 26
//liuLiu, 26
深拷贝
MyPlayer::MyPlayer(const char *data_source, JNICallbakcHelper *helper) {
// 如果被释放,会造成悬空指针
// this->data_source = data_source;
// 深拷贝
// this->data_source = new char[strlen(data_source)];
// 这里C层会自动拼接 \0,strlen不计算\0长度,需要手动加上 \0
this->data_source = new char[strlen(data_source) + 1];
strcpy(this->data_source, data_source);
this->helper = helper;
}
析构函数
CMakeLists.txt
People.h
#include <iostream>
class People {
public: // 构造函数
// 无参构造函数
People();
// 一个参数构造函数
People(char * name);
// 析构函数
~People();
private: // 私有属性
char * name;
public: // get set
char * getName();
void setName(char * name);
};
People.cpp
#include "People.h"
People::People() {
std::cout << "empty parameter" << std::endl;
}
People::People(char *name) {
this->name = name;
std::cout << "one parameter." << name << std::endl;
}
// delete people的时候,会调用析构函数
People::~People() {
std::cout << "~People." << std::endl;
}
char * People::getName(){
return this->name;
}
void People::setName(char * name) {
this->name = name;
}
main.cpp
#include "People.h"
int main() {
People * people = new People("liuLiu");
std::cout<< people->getName() << std::endl;
delete people;
people = NULL;
return 0;
}
//one parameter.liuLiu
//liuLiu
//~People.
构造函数和析构函数调用顺序
#include <iostream>
class Person {
public:
char * name;
Person(char * name) : name(name) {
std::cout << "Person构造函数" << std::endl;
}
~Person() {
std::cout << "Person析构函数" << std::endl;
}
};
class Student : public Person {
public:
char * name;
Student(char * name) : Person(name) {
std::cout << "Student构造函数" << std::endl;
}
~Student() {
std::cout << "Student析构函数" << std::endl;
}
};
int main() {
Student student("Derry");
return 0;
}
// 打印记录:
// Person构造函数
// Student构造函数
// Student析构函数
// Person析构函数
友元函数
友元函数1
#include <iostream>
class People {
private:
int age = NULL;
public:
People(int age) :age(age){}
int getAge() {
return this->age;
}
// 定义友元函数 声明
friend void updateAge(People * people, int age);
};
// 实现
void updateAge(People * people, int age) {
// 默认不能修改私有的age,通过友元函数可以修改
people->age = age;
}
int main() {
People people1 = People(23);
updateAge(&people1, 88);
std::cout << "people1.getAge(): " << people1.getAge() << std::endl;
return 0;
}
友元函数2
CMakeLists.txt
cmake_minimum_required(VERSION 3.17)
project(mycpptest)
set(CMAKE_CXX_STANDARD 14)
add_executable(mycpptest main.cpp People.cpp People.h)
People.h
#include <iostream>
class People {
private:
int age = NULL;
public:
People(int age);
int getAge();
// 友元函数 声明
friend void updateAge(People * people, int age);
};
People.cpp
#include "People.h"
People::People(int age) {
this->age = age;
}
int People::getAge() {
return this->age;
}
// 友元函数实现 不需要 对象::,只需要保证函数名和参数即可
void updateAge(People * people, int age) {
people->age = age;
}
main.cpp
#include "People.h"
int main() {
People people1 = People(23);
updateAge(&people1, 88);
std::cout << "people1.getAge(): " << people1.getAge() << std::endl;
return 0;
}
友元类
#include <iostream>
class People {
private:
int age = NULL;
friend class Class; // 友元类
};
class Class {
public:
People people;
void changeAge(int age) {
people.age = age;
}
int getAge() {
return people.age;
}
};
int main() {
Class peopleClass;
peopleClass.changeAge(22);
std::cout << peopleClass.getAge() << std::endl;
return 0;
}
运算符重载
类外运算符重载
#include <iostream>
class People {
private:
int number1, number2;
public:
People(int number1, int number2) :number1(number1), number2(number2) {}
void setNumber1(int number1) {
this->number1 = number1;
}
void setNumber2(int number2) {
this->number2 = number2;
}
int getNumber1(){
return this->number1;
}
int getNumber2(){
return this->number2;
}
};
People operator + (People people1, People people2) {
int number1 = people1.getNumber1() + people2.getNumber1();
int number2 = people1.getNumber2() + people2.getNumber2();
People peo(number1, number2);
return peo;
}
int main() {
People people1(10, 20);
People people2(30, 40);
People people = people1 + people2;
std::cout << people.getNumber1() << ", " << people.getNumber2()<< std::endl;
return 0;
}
类内运算重载
#include <iostream>
class People {
private:
int number1, number2;
public:
People(int number1, int number2) :number1(number1), number2(number2) {}
void setNumber1(int number1) {
this->number1 = number1;
}
void setNumber2(int number2) {
this->number2 = number2;
}
int getNumber1(){
return this->number1;
}
int getNumber2(){
return this->number2;
}
// 方式1
// People operator + (People people){
// int num1 = this->number1 + people.getNumber1();
// int num2 = this->number2 + people.getNumber2();
// return People(num1 ,num2);
// }
// 方式2
People operator + (const People & people){
int num1 = this->number1 + people.number1;
int num2 = this->number2 + people.number2;
return People(num1 ,num2);
}
// ++a
void operator ++ () {
this->number1 = this->number1 + 1;
this->number2 = this->number2 + 1;
}
// a++
void operator ++ (int) {
this->number1 = this->number1 + 1;
this->number2 = this->number2 + 1;
}
};
int main() {
People people1(10, 20);
People people2(30, 40);
People people = people1 + people2;
std::cout << people.getNumber1() << ", " << people.getNumber2()<< std::endl;
People people3(100, 200);
people3++;
++people3;
std::cout << people3.getNumber1() << ", " << people3.getNumber2()<< std::endl;
return 0;
}
继承
#include <iostream>
class People {
private:
char * name;
int age = NULL;
public:
People(char * name, int age) :name(name), age(age) {
std::cout << "Person 构造函数" << std::endl;
}
void print() {
std::cout << this->name << ", " << this->age << std::endl;
}
};
// 公开继承
class Student : public People{
private:
char * address;
public:
Student(char * name, int age, char * address) :People(name, age) , address(address){
std::cout << "Student 构造函数" << std::endl;
}
void test() {
print();
}
};
int main() {
Student student("zhangSan", 21, "xxx");
student.test();
return 0;
}
多继承1
#include <iostream>
class People1 {
public:
void show(){
std::cout << "People1 show" << std::endl;
}
void play(){
std::cout << "People1 play" << std::endl;
}
};
class People2 {
public:
void study(){
std::cout << "People2 study" << std::endl;
}
void play(){
std::cout << "People2 play" << std::endl;
}
};
// 公开继承
class Student : public People1, public People2{
public:
void study(){
std::cout << "Student study" << std::endl;
}
};
int main() {
Student student;
student.study();
// 会有歧义
// student.play();
// 避免歧义
student.People1::play();
student.People2::play();
return 0;
}
多继承2
#include <iostream>
class Object {
public:
int number;
};
class People1 : public Object{
};
class People2 : public Object{
};
// 公开继承
class Student : public People1, public People2{
public:
int number;
};
int main() {
Student student;
// 有歧义
// student.number;
// 避免歧义
student.People1::number;
student.People2::number;
// 避免歧义,子类覆盖掉即可
student.number;
return 0;
}
虚基类
#include <iostream>
class Object {
public:
int number;
};
class People1 : virtual public Object{
};
class People2 : virtual public Object{
};
// 公开继承
class Student : public People1, public People2{
};
int main() {
Object object;
People1 people1;
People2 people2;
Student student;
object.number = 1;
people1.number = 2;
people2.number = 3;
student.number = 4;
std::cout << object.number << std::endl; // 1
std::cout << people1.number << std::endl; // 2
std::cout << people2.number << std::endl; // 3
std::cout << student.number << std::endl; // 4
return 0;
}
多态
动态多态
动态多态:程序在运行期间才能确定调用哪个类的函数
C++ 默认关闭多态,加上virtual即可
#include <iostream>
class BaseActivity {
public:
// C++ 默认关闭多态,加上virtual即可
virtual void onStart() {
std::cout << "BaseActivity onStart" << std::endl;
}
};
class HomeActivity : public BaseActivity{
public:
void onStart() {
std::cout << "HomeActivity onStart" << std::endl;
}
};
class LoginActivity : public BaseActivity{
public:
void onStart() {
std::cout << "LoginActivity onStart" << std::endl;
}
};
void startToActivity(BaseActivity * baseActivity) {
baseActivity->onStart();
}
int main() {
// 方式1
HomeActivity * homeActivity = new HomeActivity();
LoginActivity * loginActivity = new LoginActivity();
startToActivity(homeActivity);
startToActivity(loginActivity);
// 方式2
BaseActivity * baseActivity1 = new HomeActivity();
BaseActivity * baseActivity2 = new LoginActivity();
startToActivity(baseActivity1);
startToActivity(baseActivity2);
return 0;
}
静态多态
静态多态 : 编译期已经决定,调用哪个函数
重载(静态多态)
#include <iostream>
void add(int number1, int number2) {
std::cout << number1 + number2 << std::endl;
}
void add(float number1, float number2) {
std::cout << number1 + number2 << std::endl;
}
void add(double number1, double number2) {
std::cout << number1 + number2 << std::endl;
}
int main() {
add(1, 2);
add(1.1f, 2.1f);
add(1.2, 1.3);
return 0;
}
纯虚函数(似java接口)
纯虚函数必须被继承,否则子类就是抽象类
#include <iostream>
class BaseActivity {
public:
void onCreate() {
getLayoutID();
initView();
initData();
}
// 纯虚函数必须被继承,否则子类就是抽象类
// virtual std::string getLayoutID(); // 虚函数
virtual std::string getLayoutID() = 0; // 纯虚函数
virtual void initView() = 0; // 纯虚函数
virtual void initData() = 0; // 纯虚函数
};
// 如果没有重新父类的纯虚函数,自己就相当于 抽象类
class MainActivity : public BaseActivity {
std::string getLayoutID() {
return "xxxxx";
}
void initView() {}
void initData() {}
};
int main() {
MainActivity mainActivity;
return 0;
}
全纯虚函数(似java接口)
#include <iostream>
class Student {
public:
std::string name;
int age;
};
class IStudent {
public:
virtual void insert(Student student) = 0; // 纯虚函数
virtual void query(Student student) = 0; // 纯虚函数
};
// 如果没有重新父类的纯虚函数,自己就相当于 抽象类
class Student_Impl : public IStudent {
public:
void insert(Student student) {
std::cout << "insert" << std::endl;
}
void query(Student student) {
std::cout << "query" << std::endl;
}
};
int main() {
Student * student = new Student();
student->name = "zhangSan";
student->age = 23;
Student_Impl studentImpl;
studentImpl.insert(*student);
return 0;
}
回调
#include <iostream>
class ILoginResponse {
public:
virtual void success(int code, char * msg) = 0; // 纯虚函数
virtual void error(int code, char * msg) = 0; // 纯虚函数
};
class ILoginResponseImpl : public ILoginResponse {
public:
void success(int code, char * msg) {
std::cout << code << ", " << msg << std::endl;
}
void error(int code, char * msg) {
std::cout << code << ", " << msg << std::endl;
}
};
void loginAction(std::string userID, std::string pwd, ILoginResponse & callback) {
if (userID.empty() || pwd.empty()){
std::cout << "userID | pwd is empty!" << std::endl;
return;
}
if (userID == "zhangSan" && pwd == "123") {
callback.success(0, "login success");
} else {
callback.success(-1, "login fail");
}
}
int main() {
ILoginResponseImpl callback;
loginAction("zhangSan", "12312", callback);
return 0;
}
this
#include <iostream>
class People {
private:
char * name;
public:
static int id;
public:
void setName(char * name){
this->name = name;
}
char * getName(){
return this->name;
}
};
// 再实现
int People::id = 1001;
int main() {
People people1;
people1.setName("zhangSan1");
people1.id = 2002;
People people2;
people2.setName("zhangSan2");
people2.id = 3003;
std::cout << "people1.getName(): " << people1.getName() << ", id: " << people1.id << std::endl;
std::cout << "people1.getName(): " << people2.getName() << ", id: " << people2.id << std::endl;
std::cout << "People::id: " << People::id << std::endl;
// 静态区,没有this的区分
return 0;
}
//people1.getName(): zhangSan1, id: 3003
//people1.getName(): zhangSan2, id: 3003
//People::id: 3003
static
#include <iostream>
class People {
public:
char * name;
// 报错
// static int age = 9;
// 正确 先声明
static int age;
void update1() {
age += 1;
}
static void update2() {
age += 1;
}
};
// 再实现
int People::age = 9;
int main() {
People people;
std::cout << People::age << std::endl; // 9
People::update2(); // 静态函数
people.update2(); // 对象名.静态函数 (一般是使用::调用静态成员)
people.update1(); // 普通函数
std::cout << People::age << std::endl; // 12
return 0;
}