#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <iostream> // c++的包
#include "Student.h"
using namespace std; // 命名的空间，java中的类部内
/*
// 1. c++ 代码中可以混编 c 代码，c++ 里面写 c 代码，也可以调用
// 2. c++ 面向对象（Java），c 面向过程
// 3. 很多的开源框架大部分都是 c++ 写的 （大部分基于 c++ ）
void main(){
  // printf("Hello World");// c 的打印
  // c++ 打印  opencv   << 操作符重载
  std::cout << "Hello World!" << std::endl;
  getchar();
}

void main(){
	const int number = 10;
	// number = 20;
	// int* numberP = &number;// 不能通过地址去修改值，但是某些编译器上面能通过，但是也不能修改值
	// c 是能够修改的，在 c 中可以说是一个伪命题
	// *numberP = 20;
	// printf("%d", number);
	getchar();
}

// 引用
void swap(int &number1, int &number2){
	cout << "swap number1的地址" << &number1 << endl;
	int temp = 0;
	temp = number1;
	number1 = number2;
	number2 = temp;
}
void main(){
	int number1 = 10;
	int number2 = 20;
	// 引用： 四驱模型值的拷贝，引用其实是地址赋值 ，可以看成同一块内存的另外一个变量
	cout << "main number1的地址" << &number1 << endl;
	swap(number1,number2);
	cout << "number1 = " << number1 << " , number2 = " << number2 << endl;
	getchar();
}
//------------------------------------------------------------------------------------------------
//常量引用
typedef struct 
{
	char name[20];
	int age;
}Student;

void insertStu(const Student &stu){// stu 不想改 常量引用
	// 可以修改 stu 的值
	// strcpy(stu.name,"Jack");
	// 就变成了只读
	cout << stu.name << "," << stu.age << endl;
}
void main(){
	Student stu = {"Darren",20};
	insertStu(stu);
	getchar();
}

// 1.函数重载和默认参数
int add(int number1, int number2 = 200, bool cache= 0){ // number2 = 200 默认的参数 kotlin 很像
	return number1 + number2;
}
// 错误	1	error C2084: 函数“int add(int,int)”已有主体  c 不允许函数的重载
int add(int number1, int number2, int number3){
	return number1 + number2 + number3;
}

void main(){
	int number1 = 100;
	int number2 = 200;
	int sum = add(number1,200);//报错
		
	// bool 类型 0是true 和 !0 都是false
	bool cache = -100;
	if (cache){
		cout << "true" << endl;
	}else
	{
		cout << "false" << endl;
	}
	// printf("sum = %d", sum);
		
	getchar();
}

1.class 定义类，跟java 几乎类似
2.真正的开发过程中我们的 pp 或者  文件，最终 d 或者  库供调用者使用，所以为了确保类能正常被调用，我们般需要定义.h 头文件
3实现方法的使用要用命名空间 xxx类名::xxx方法

class Student{ // 结构体类似
private: // 私有，包装，影响下面所有的属性
	char* name;
	int age;
public:
	void setAge(int age);

	void setName(char* name);
	// private: // 影响到下面的所有方法

	int getAge();

	char* getName();
};

#include "Student.h"
// 写实现 ,定义了另外一个方法
void Student::setAge(int age){// 实现 Student 的 setAge 方法
	this->age = age;
}
void Student::setName(char* name){
	this->name = name;
}
int Student::getAge(){
	return this->age;
}
char* Student::getName(){
	return this->name;
}

class Person
{
 private:
	 int age = 0;
public:
	// 如果有自己写构造函数，那么会默认覆盖无参的构造函数
	Person(int age){
		this->age = age;
	}
	int getAge(){
		return this->age;
	}
	// 友元函数的声明
	friend void friend_change(Person *person, int age);
};
// 友元函数的实现
void friend_change(Person *person, int age){
	// 修改一下 age 的值
	// 在类的内部才能访问私有属性
	// 如果该方法声明成友元函数那么是可以在外部访问其私有属性的
	person->age = age;
}
void main(){
	Person person = Person(24);
	friend_change(&person,36);
	cout << person.getAge() << endl;
	getchar();
}

#ifndef STUDENT_H
#define STUDENT_H

class Student{
private:
	int age;
	char* name;
public:
	// 静态属性的声明
	static int tag;

public:
	Student();
	Student(char* name);
	Student(char* name,int age);
	// 析构函数
	~Student();
	// 拷贝构造函数
	Student(const Student& stu);

public:
	void setAge(int age);
	void setName(char* name);

	int getAge();
	char* getName();

	void print() const;

	// 静态和友元
	static void changeTag(int tag);
	friend void changeAge(Student *stu,int age);
};
#endif // STUDENT_H

#include <iostream>

using namespace std;

/*
class  Vector
{
public:
	Vector(int x, int y){
		this->x = x;
		this->y = y;
	}

	Vector(const Vector &vector){
		this->x = vector.x;
		this->y = vector.y;
		cout << "拷贝构造函数" << endl;
	}
private:
	int x;
	int y;

public:
	void setX(int x){
		this->x = x;
	}
	void setY(int y){
		this->y = y;
	}

	int getX(){
		return this->x;
	}
	int getY(){
		return this->y;
	}

	// 重载减号运算符
	// 为什么要用引用，为了防止重复创建对象
	// const 关键常量，为了防止去修改值
	Vector operator - (const Vector &vector){
		int x = this->x - vector.x;
		int y = this->y - vector.y;
		Vector res(x, y);
		return res;// 不建议返回引用
	}

	// 自增减运算符
	void operator ++ (){// ++X
		this->x = this->x++;
		this->y = this->y++;
	}

	void operator ++ (int){// X++
		this->x = this->x++;
		this->y = this->y++;
	}

	// 自减
	// 输出运算符
	friend ostream & operator << (ostream &_Ostr, const Vector &vector){
		_Ostr << vector.x << "," << vector.y << endl;
		return _Ostr;
	}

	// 条件运算符
	bool operator == (const Vector &vector){
		return (this->x == vector.x && this->y == vector.y);
	}

	// 括号运算符
};

// 定义在类的外面，一般来讲我们定义在类的里面
// 重载运算 + ：operator +
Vector operator + (Vector vector1, const Vector vector2){
	int x = vector1.getX() + vector2.getX();
	int y = vector1.getY() + vector2.getY();
	Vector vector(x,y);
	return vector;
}

void main(){
	Vector vector1(2, 3);
	Vector vector2(2, 3);

	// java 中 string + string 

	// char* str = "123" + "456";

	// 重载运算符 +
	// Vector vector = vector1 - vector2;

	// Vector vector(1, 2);
	// vector++;
	// ++vector;

	// cout << vector.getX() << " , " << vector.getY() << endl;
	// cout << vector << vector;
	bool isEqual = vector1 == vector2;
	cout << isEqual << endl;
	// 可以重载加其他对象 Person
	getchar();
}

// 括号运算符
class Array
{
public:
	Array(int size){
		this->size = size;
		this->array = (int*)malloc(sizeof(int)*size);
	}
	~Array(){
		if (this->array){
			free(this->array);
			this->array = NULL;
		}
	}

	Array(const Array& array){
		this->size = array.size;
		this->array = (int*)malloc(sizeof(int)*array.size);

		// 值的赋值
		for (int i = 0; i < array.size; i++)
		{
			this -> array[i] = array.array[i];
		}
	}

private:
	int size;
	int* array;

public:
	void set(int index,int value){
		array[index] = value;
	}

	int get(int index){
		return this->array[index];
	}

	int getSize(){
		return this->size;
	}

	// 操作符[]
	int operator[](int index){
		return this->array[index];
	}
};

void printfArray(Array array){
	for (int i = 0; i < array.getSize(); i++)
	{
		cout << array[i] << endl;
	}
}

void main(){
	
	Array *array = new Array(5);

	array->set(0,0);
	array->set(1, 1);
	array->set(2, 2);

	printfArray(*array);

	delete(array);
	getchar();
}

class Person{
	// 变量修饰符
public:// 本类中使用
	// protected ：子类中能使用 （默认）
	// public ：公开，任何地方都可以
	char* name;
	int age;

public:
	Person(char* name,int age){
		this->name = name;
		this->age = age;
		cout << "Person 构造函数" << endl;
	}

public:
	void print(){
		cout << this->name << " , " << this->age << endl;
	}
};

// 类继承 语法 : 
// 类继承修饰符 public
class Student : public Person
{
public:
	// : Person(name,age) 调用构造函数初始化父类的属性
	Student(char* name,int age):Person(name,age){// 调用父类构造函数
		cout << "Student 构造函数" << endl;
	}
	
	void test(){
		print();
	}
};
void main(){
	Student stu("Darren",24);

	stu.name = "Jack";

	getchar();
}

// 初始化属性
class Person{
	// 变量修饰符
public:// 本类中使用
	// protected ：子类中能使用 （默认）
	// public ：公开，任何地方都可以
	char* name;
	int age;

public:
	Person(char* name, int age){
		this->name = name;
		this->age = age;
		cout << "Person 构造函数" << endl;
	}

public:
	void print(){
		cout << this->name << " , " << this->age << endl;
	}
};


class Student : public Person
{
private:
	char* course;
public:
	// : Person(name,age) 调用构造函数初始化父类的属性
	// 不光可以给父类初始化属性，还可以给本类的属性进行初始化，用 , 隔开即可
	Student(char* name, int age, char* course) :Person(name, age), course(course){// 调用父类构造函数
		cout << "Student 构造函数" << endl;
	}

	void print(){
		cout << "course: " << course << endl;
	}
};

class Teacher: public Person
{
public:
	Teacher(char*name,int age):Person(name,age){
		
	}
};

void main(){
	Student stu("Darren",24,"语文");
	stu.print();
	getchar();
}

class Person{
private:
	char * name;
public:
	Person(char * name){
		this->name = name;
	}
	char* _name(){
		return this->name;
	}
};
class Child
{
	int age;
public:
	Child(int age){
		this->age = age;
	}
	int _age(){
		return this->age;
	}
};
class Student : public Person, public Child // 多继承 , 并没有实现
{
public:
	Student(char* name,int age):Person(name),Child(age){
	}
};
	
void main(){
	// 构造函数：先父类 -> 再子类
	// 析构函数：先子类 -> 再父类
	Student *stu = new Student("Darren",24);
	delete stu;
	getchar();
}

class A{
public:
	char* name;
};
class B : virtual public A{ //不加virtual会运行时报错，virtual确保继承过来的相同属性或者函数，只存在一份拷贝
};
class C :virtual public A{
};
class D : public B ,public C
{
};
void main(){
	D d;
	d.name="darren";
	cout<<d.name<<endl;
	getchar();
}

class Activity
{
public:
	virtual void onCreate(){ // 支持多态，虚函数
		cout << "Activity 中的 onCreate" << endl;
	}
};

class MainActivity : public Activity
{
public:
	void onCreate(){
		cout << "MainActivity 中的 onCreate" << endl;
	}
};

class WelcomeActivity : public Activity
{
public:
	void onCreate(){
		cout << "WelcomeActivity 中的 onCreate" << endl;
	}
};

void startActivity(Activity* activity){
	activity->onCreate();
}

void main(){
	Activity *activity1 = new MainActivity();// 父类 = new 子类对象
	Activity *activity2 = new WelcomeActivity();

	// activity->onCreate();
	// c++ 中的多态是怎样的，默认情况下不存在
	// 父类指向子类的引用，重写 ，里氏替换原则 
	// 程序在编译期间并不知晓运行的状态（我需要运行那个函数），只要在真正运行的过程中才会去找需要运行的方法
	startActivity(activity1);
	startActivity(activity2);

	// c++ 多态：动态多态(子父类)，静态多态（函数的重载）（编译过程确定性的区别）
	getchar();
}

// 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();
}

class ClickListener{// 所有的函数都是虚函数，那么就可以认为是接口
public:
	virtual void click() = 0;
};
class ImageClickListener : public ClickListener
{
public :
	void click(){
		cout << "图片点击" << endl;
	}
};
void click(ClickListener *listener){
	listener->click();
}
void click(){
	cout << "click点击" << endl;
}
// 函数指针 07 次
void click(void(*c)()){// 函数指针作为参数传递  返回值(函数名)(参数)
	// 压缩开始
	c();// 输出压缩进度
	// 压缩结束
}
	
void main(){
	// 函数指针的时候：回调可以用 指针函数作为回调，纯虚函数类进行回调（接口）
	// ClickListener *listener = new ImageClickListener();
	// listener->click();
	// click(listener);
	// 自己再去了解加深一下
	click(click);
	getchar();
}

class Person
{
protected:
	char* name;
	int age;
public:
	Person(char* name, int age){
		this->name = name;
		this->age = age;
		cout << "Person 的构造函数" << endl;
	}
	~Person(){
		cout << "Person 的析构函数" << endl;
	}
};

class Student : public Person
{
public:
	Student(char* name, int age) : Person(name, age){ // 初始化父类的属性
		cout << "Student 的构造函数" << endl;
	}
	~Student(){
		cout << "Student 的析构函数" << endl;
	}
};

void main(){
	// 构造函数：先父类 -> 再子类
	// 析构函数：先子类 -> 再父类
	Student *stu = new Student("Darren",24);
	delete stu;
	getchar();
}

int add(int number1, int number2){
	return number1 + number2;
}

double add(double number1, double number2){
	return number1 + number2;
}

float add(float number1, float number2){
	return number1 + number2;
}
// 模板函数  算法4 看一遍敲一遍
// 当普通函数和模板函数同时存在的时候，优先会调用普通函数
template <typename T>// 模板函数的定义
T add(T number1, T number2){
	return number1 + number2;
}
	
void main(){
	int sum1 = add(1,2);
	cout << sum1 << endl;
	int sum2 = add(1.0, 2.0);
	cout << sum2 << endl;
	int sum3 = add(1.0f, 2.0f);
	cout << sum3 << endl;
	getchar();
}

template <typename T>
class Callback
{
public:
	void onError(){
	}
	void onSucceed(T result){
		cout << result << endl;
	}
};

// 模板类继承 ，子类如果也是模板类
// 如果子类不是模板类
class HttpCallback : public Callback<int>
{
};
template <class T>
class HttpCallback : public Callback<T>
{
};

void main(){
	HttpCallback<int> *callback = new HttpCallback<int>();
	callback->onSucceed(12);
	getchar();
}

1.1 static_cast 静态转换  用于基本数据类型之间的转换，如把int转换成char
1.2 const_cast 常量转换 用于修改常量的值
1.3 reinterpret_cat 强制类型转换 ，用于转换任意类型
1.4 dynamic_cast 动态转换 ，更安全，转换成功返回类型，失败返回空 ，
      必须要包含多态类型和 static_cast 很类似，但是更安全

#include <iostream>
using namespace std;
class Person{
public:
	string name;
	int age;
public:
	Person(string name, int age){
		this->name = name;
		this->age = age;
	}
};

class Student : public Person{
public:
	Student(string name, int age) : Person(name,age){
	}
};

class Worker : public Person{
};

void main(){
	double number1 = 20.02;
	// 直接转换
	// int number2 = number1;
	// 1. 用于基本数据类型之间的转换，如把int转换成char
	// int number2 = static_cast<int>(number1);
	// cout << number2 << endl;
	// 2. 把类型转换成另一种类型，用于类层次结构中基类和派生类之间指针或引用的转换
	// Student *stu = new Student("Darren",24); // jobejct -> objectArray
	// Person *person = stu;
	// Person *person = static_cast<Person *>(stu);
		
	// 待会再试
	Person person = Person("Darren", 24);
	// 转成Student
	// Student stu = person;
	cout << person.name.c_str() << " , " << person.age << endl;
	getchar();
}

// NDK 异常总结
// 1. 在 c++ 层如果是自己写的代码或者调用别人的方法，记得要 try 住， 如果不 try 在 java 层 try 是没有意义的
// 2. 如果异常需要往外抛给 java 层，一定要按照java层抛异常的方式
// 3. 如果是自己写的 NDK 层的代码，最好抛自己写的异常，声明异常
// 4. 如果是做 c++/c , 或者是帮 c/c++ 写代码，最好抛系统定义好的异常或者继承系统的异常
// 5. 系统异常的体系  exception 基类  https://www.cnblogs.com/QG-whz/p/5136883.html
class Exception
{
public:
	string msg;
public:
	Exception(string msg){
		this->msg = msg;
	}
public:
	const char *what(){
		return this->msg.c_str();
	}
};
// 异常的处理
void main(){
	// c++ 中有自己一套异常的体系，不要去强记
	// 但是 c++ 可以抛任何数据类型 try{}catch(数据类型 变量名){}
	// throw 抛异常
	 try{
		int i = -1;
		if (i == 0){
			throw Exception("出异常了");
		}
		if (i< 0){
			throw 12.5f;
		}
	 }
	catch (int number){
		cout << "捕捉到异常" <<number << endl;
	}
	catch (Exception exception){
		cout << "捕捉到异常:" << exception.what() << endl;
	}
	catch (...){
		cout << "捕捉到其他异常:" << endl;
	}
	getchar();
}

void main(){
	// C++ STL(Standard Template Library) 准模板库 ：容器 + 迭代器 + 算法
	// 1. 对象的构建
	string str1 = "123";
	string str2("123");
	string str3(5, 'A');// 5 个 A = AAAAA
	string *str4 = new string("123");

	// cout << str1.c_str() <<endl;
	// cout << str2.c_str() << endl;
	// cout << str3.c_str() << endl;
	// cout << str4->c_str() << endl;

	// string 与 char* 相互之间转换 c_str()
	// const char* c_str1 = str1.c_str();
	// cout << c_str1 << endl;

	// char* -> string
	char* c_str = "Darren";
	string str(c_str);// 对象
	cout << str.c_str() << endl;

	getchar();
}

#define D_SCL_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

void main(){
	string str("1234567");
	// 1. 字符串的遍历
	for (int i = 0; i < str.length(); i++)
	{
		cout << str[i] << endl;
	}
	// 迭代器遍历
	for (string::iterator it = str.begin(); it < str.end(); it++)
	{
		cout << *it << endl;
	}
	
	try{
		for (int i = 0; i < str.length()+2; i++)
		{
			cout << str.at(i) << endl;// 如果越界会抛异常
		}
		for (int i = 0; i < str.length()+2; i++)
		{
			cout << str[i] << endl;// 会导致程序宕机，AS里面是可以的
		}
	}
	catch (...){
		cout << "异常了" << endl;
	}
	getchar();
}

void main(){
	// 添加
	string str1 = "123";
	string str2 = "456";
	// str1 = str1 + str2;
	// str1.append(str2);
	cout << str1.c_str() << endl;
	
	// 删除
	string str1 = "123 abc 123 abc 123";
	// str1.erase(0,3);// 第一个参数：从哪里开始 ； 第二个参数：删除几个（默认值，字符串的结尾）
	// 迭代器删除  2 bc 123 abc 123 解释
	for (string::iterator it = str1.begin(); it<str1.begin()+3; it++)// 删除一个字后都会从头开始计算
	{
		str1.erase(it);
	}
	cout << str1.c_str() << endl;
	
	//替换
	string str1 = "123 abc 123 abc 123";
	// 第一个参数：从哪里开始
	// 第二个参数：替换几个
	// 第三个参数：替换成谁
	str1.replace(0,6,"1234");
	cout << str1.c_str() << endl;
	
	//查找
	string str1 = "123 abc 123 abc 123";
	// 查找谁，从哪里开始
	// int position = str1.find("123",0);
	// 从后面往前面查
	int position = str1.rfind("123");
	cout << position << endl;
	
	//#include <algorithm>// STL 算法包
  //#include <cctype> 
	//大小写转换
	string str1 = "AAA abc BBB abc 123";
	// 转换成大写
	// transform(str1.begin(), str1.end(), str1.begin(), toupper);
	transform(str1.begin(), str1.end(), str1.begin(), tolower);
	cout << str1.c_str() << endl;
	
	getchar();
}

#include <iostream>

#include <vector>
#include <stack>
#include <queue>
#include <list>
#include <functional>
#include <set>

using namespace std;

/*
void main(){ // vector 数组

	// vector 
	// 1. vector<int> v;
	// 2. vector<int> v(10);
	// 3. vector<int> v(10,0);
	vector<int> v;
	// 插入数据
	// v.begin() 迭代器的开始位置
	v.insert(v.begin(),12);
	v.insert(v.begin(), 22);
	v.insert(v.begin(), 32);

	v.insert(v.end(), 42);

	// 引用当左值当右值 (修改)
	v.front() = 33;//最前
	v.back() = 44;//最后

	v.push_back(55);//最后处添加
	// 移除最后的元素，并没有返回值
	// v.pop_back();
	// 通过迭代器位置进行移除
	v.erase(v.begin());
		
	// 获取数据 for 循环
	for (int i = 0; i < v.size(); i++)
	{
		cout << v[i] << "\t";// 越界程序宕机
	}
	cout << endl;
	//
	for (int i = 0; i < v.size(); i++)
	{
		cout << v.at(i) << "\t"; // 越界抛异常 out_of_range
	}
	cout << endl;

	// 通过迭代器
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << "\t"; // 越界抛异常 out_of_range
	}
	cout << endl;

	getchar();
}

void main(){
	stack<int> s;
	// 压栈 ，压入指定位置
	s.push(12);
	s.push(22);
	s.push(32);

	// 并不能够通过角标去插入获取值，如果在开发的过程中如果的确需要通过角标去获取值，需要自定义
	for (int i = 0; i < s.size(); i++)
	{
		cout << s. << endl;
	}
	// 迭代器也没有，并不支持循环的 ，非得循环
	
	for (stack<int>::iterator it; i < s.size(); i++)
	{
		cout << s. << endl;
	}
	
	int top = s.top();
	cout << top << endl;

	// 弹出栈顶
	s.pop();
	top = s.top();
	cout << top << endl;

	while (!s.empty())
	{
		int top = s.top();
		cout << top << endl;
		s.pop();
	}

	getchar();
}

void main(){

	queue<int> q;
	q.push(12);
	q.push(44);
	q.push(32);

	q.front() = 42;
	cout << q.front() << endl;
	q.pop();
	cout << q.front() << endl;
	// 最后，最后加入的
	int back = q.back();
	cout << back << end
	while (!q.empty())
	{
		cout << q.front() << endl;
		q.pop();
	}

	getchar();
}