C++基础知识

int a; int &b = a;

#include <iostream>
using namespace std;//typedef //类型重定义
/*C语言使用指针存储变量的地址 可以由指针对变量操作C++语言弱化指针的概念，引入了 引用 的概念格式：类型 &引用变量名 = 需要引用的变量[C语言中的空指针NULL C++中空指针nullptr]*/
void exchange(int &x, int &y);
int main()
{/*int a = 10;int *p = &a;        //int*类型的指针p指向int类型变量*p = 50;            //将a改为50int &b = a;cout << b << endl;  //引用就是给变量起别名，引用必须和要引用的变量是同类型char m = 'A';char &n = m;cout << n << endl;  //通过引用也可以修改原有变量的内容n = 'a';cout << n << endl;*/int a = 10;int b = 40;int &c = a;//c = b;          //引用无法修改指向exchange(a, b);cout << a << "  " <<b << endl;return 0;
}/* 引用的产生主要是为了函数传参(传参类的对象) */
void exchange(int &x, int &y){int temp = 0;temp = x;x = y;y = temp;
}
/*引用 和 指针的区别1. 指针是一个变量，占8字节（64系统），系统会为其分配至地址引用不是变量，不占空间，只是原本变量的别名2. 指针可以修改指向，但是引用一旦定义就无法修改指向，因为依赖于变量存在3. 指针定义的时候可以不初始化，但是引用定义的同时必须初始化
*/

#include <iostream>
using namespace std;/*内置函数 / 内联函数 / 内嵌函数称以下体积较小并且逻辑简单，调用次数较多的函数为内置函数如果函数体内部逻辑复杂，while，for,if等判断循环分支语句都不建议设置为内置函数格式：在函数名称前加上关键字inline[加上关键字知识给编译器提建议，具体是否将函数设置为内置函数还是要看编译器的判断结果][如果函数过于复杂，编译器将函数看作普通函数对待]
*//*如果在程序中要重复多次的执行简单动作，例如函数
跳转时间 1ms
函数执行时间 0.5ms
函数如果在程序中调用100次 跳转时间一共就100ms
如果函数体转换时间花费较多可以将函数设置为内联函数实现过程：将实参传给形参，将形参拷贝到函数体内部再将函数体内部执行程序替换到主程序中调用该函数的位置*/
inline void printInfo(string name, int id){cout << name << "  " << id << endl; 
}int main(){printInfo("A", 1000);printInfo("B", 1001);printInfo("C", 1002);cout << "D" << "  " << 1003 << endl; //....return 0;

通用类型定义 
template <typename XXX> 
template 的含义是"模板",
<>中先写关键字 typename 或 class ,后边跟一个类型参数 
XXX,类似标识符, 是一个虚拟的类型名

2.5 动态内存分配

/* 开辟一个存放整型的存储空间，返回一个指向该存储空间的地址(指针) */ 
int *p = new int; 
/* 开辟一个存放整型的存储空间，并指定该整数的初值为 100 */ 
int *p = new int(100); 
/* 开辟一个存放二维整型数组的空间，返回首元素的地址 */ 
int (*p)[4] = new int[5][4]; 
new 运算符使用的一般格式为：new 类型(初值) 用 new 分配数组空间时不能指定初值。 
如果由于内存不足等原因而无法正常分配空间，则 new 会返回一个空指针 NULL，用户可以根据该指针的值判 断分配空间是否成功。 delete 运算符使用的一般格式为：delete []指针变量 对基本数据类型的申请可以直接释放。 
如果是类似"char *pt = new char[10]"申请的字符数组空间(构造数据类型空间)，释放时应在指针变量前 加一对方括号，表示是对数组空间的操作：delete []pt;

#include <iostream>
using namespace std;/*C语言中使用malloc free进行堆区空间的申请和释放void * malloc()C++ 使用new delete
*/typedef struct Person{string name;int age;
}P_t;
int main(){int *p = new int;	//申请4字节空间int *q = new int(50);	//申请4字节空空间的同时初始化*p = 100;cout << *p << endl;		//100cout << *q << endl;		//50int *t = new int[10];	//申请10个连续的4字节空间for(int i=0; i<10;i++){	//循环初始化*(t+i) = i;}for(int i=0; i<10;i++){cout << *(t+i) << endl;}int *T = new int[5]{8,5,2,3,0};	//申请同时初始化for(int i=0; i<5;i++){cout << *(T+i) << endl;}struct Person *L = new P_t{("Zhang"), 90};delete p;delete q;delete []t;           //动态申请的连续空间在释放时要加上[]delete []T;delete L;return 0;
}

class 类名 
{访问修饰符: // 
属性 type name; // 
方法 type method(); };
// 和结构体类型定义相同 类的定义需要以分号结尾

#include <iostream>
using namespace std;
/** 在C语言结构体中不能定义或者实现函数，在c++中结构体可以* 在类中也可以直接定义以及实现函数*  类  class*  类中的内容：分为两种变量(属性)和函数(方法)*  定义类的格式：*      class 类名{*          //类中的成员函数以及成员变量*      }**  类中成员有三种访问修饰符 public protected private*  public:公开成员，类内类外都可以访问*  protected: 保护成员，类内可以访问，类外不能访问，但是继承类可以访问*  private：私有成员，类外不可访问，继承类也不能，友元类和友元函数可以访问**  类中如果没有任何访问修饰符，那么全部成员是私有的*/
class myclass{
public:string name;int age;friend void friendFunc();           //声明友元函数，此类中的私有成员在友元函数种可以访问问friend class fclass;void inputInfo(string t_name, int t_age){name = t_name;age = t_age;}void ouptInfo(){cout << "name=" + name << "  " << "age=" << age <<endl;}
private:int private_num;
};void friendFunc(){myclass user2;user2.private_num = 100;   //在友元函数种访问私有成员
}int main()
{//使用自定义的类定义对象 -- 实例化类myclass user;//调用成员函数对成员变量赋值user.inputInfo("Zhang", 20);user.ouptInfo();return 0;
}

2.2构造函数/析构函数

myclass.h：

#ifndef MYCLASS_H
#define MYCLASS_H
#include <iostream>
using namespace std;
/** 构造函数和析构函数由系统生成并调用，不由用户调用*  构造函数在对象生命周期开始的时候被调用*  析构函数在生命周期结束时候被调用*/class myclass{
public://无参构造函数-默认myclass();             //构造函数函数名和类名相同，没有返回值，可以传参数，可以被重载~myclass();            //构造函数函数名是类名加上~，没有返回值，不可以传参数，不可以被重载//如果在类内显式声明构造函数就要实现myclass(string name, int age);              //构造函数重载myclass(string name, int age, char sex);    //构造函数重载myclass(const myclass &obj);                //拷贝构造函数-将另外一个对象的全部内容拷贝给当前的对象//编译器也会自动生成拷贝构造函数可以直接使用void outputInfo(){              //该函数为公开函数，可以在类外访问该函数，间接访问或者修改私有成员cout << name << endl;cout << age << endl;cout << sex <<endl;//this->name; //在普通成员函数内可以使用this}static int num;     //静态成员变量static void static_func(){//cout << this << endl;     //静态成员函数中不能使用thiscout << "staic func " << endl;}protected:
private:		//私有成员 类外无法访问 [友元函数可以]string name = "Zhang";int age;char sex;
};#endif // MYCLASS_H

myclass.cpp：

#include "myclass.h"myclass::myclass(){cout << "无参构造函数：" << name <<"生命周期开始" <<  endl;
}myclass::~myclass(){cout << "析构函数：" << name <<"生命周期结束" <<  endl;
}//构造函数重载
myclass::myclass(string name, int age){this->name = name;              //在函数体内部初始化成员变量this->age = age;cout << "有参构造函数：" << name <<"生命周期开始" <<  endl;
}
//this指针：只能在类内的成员函数中使用，指向调用成员函数的对象，是一个无类型的指针(静态成员函数中不能用this指针)//构造函数重载--形参初始化列表  -> 要初始化的成员名称(形参) 以逗号分隔开
myclass::myclass(string name, int age, char t_sex) : name(name), age(age), sex(t_sex){cout << "有参构造函数：" << name <<"生命周期开始" <<  endl;
}//拷贝构造函数 自定义并实现
myclass::myclass(const myclass &obj){name = obj.name;age = obj.age;sex = obj.sex;
}

main.cpp：

#include "myclass.h"//在c++源文件种，可以定义结构体在结构体定义并实现函数
//结构体种的函数默认的访问修饰符public
//也可以使用其他两个修饰符//结构体类型    变量
//类 (数据类型) 对象(变量)int myclass::num = 80;			//静态成员函数必须在类外部定义一次int main()
{
/*myclass u1;             //对象的生命周期开始myclass u2("Wang", 50); //有参构造函数--重载u2.outputInfo();myclass u3("Liu", 10, 'm');  //有参构造函数--重载u3.outputInfo();myclass u4(u3);         //拷贝 构造函数u4.outputInfo();
*/myclass user;myclass::static_func();         //静态成员变量以及静态成员函数访问方式//1. 使用类定义对象，通过对象进行访问//2. 直接使用类加上访问限定符访问静态成员(变量/函数)cout << myclass::num++ << endl; //80cout << myclass::num++ << endl; //81cout << myclass::num << endl;   //82return 0;
}

2.3继承/抽象类/虚函数/多态

#include <iostream>
using namespace std;/* 基类 父类 */
class Parent{
public:                 //类内外string name;Parent(){cout << "父类的无参构造函数" << endl;}Parent(int num){this->private_num = num;cout << "父类的构造函数重载" << endl;}void outputInfo(){cout << name << endl;cout << age << endl;}virtual void buy(){cout << "父类 全价" << endl;}protected:          //只能在类内访问和派生类中访问int age;private:            //只能在类内访问 和 友元函数内int private_num;
};/* 派生类 子类 */
//格式 class 类名 : 继承方式 父类名称{}
class Child : public Parent{//默认存在基类中公开的成员//可以再定义一些派生类的成员
public:Child(){cout << "子类的无参构造函数" << endl;}virtual void buy(){         //覆盖  override重写cout << "子类 半价" << endl;}
};class abclass{
public:virtual void abfunc() = 0;            //纯虚函数  含有纯虚函数的类叫做抽象类-无法实例化的类
};//如果继承自抽象类的派生类不重写基类中的纯虚函数，那么派生类也是抽象类，无法实例化
class son_abclass: public abclass{          //抽象类的派生类
public:virtual void abfunc() override{cout << "这是派生类的重写" << endl;}
};void func(Parent &p){p.buy();
}//多态：不同对象调用同一接口时有不同的动作
int main()
{//使用派生类定义对象  可以直接访问基类中的公开成员//Child child1;
/*Parent p1;      //基类对象Child c1;       //派生类对象Parent *P;P = &p1;P->buy();		//如果基类和派生类没有加上virtual，那么此处和79行P->buy()都会调用基类中的buy函数P = &c1;P->buy();		//如果在基类以及子类中的成员函数都没有使用virtual进行修饰==没有满足多态//那么调用函数时会根据指针的类型调用，也就是说基类的指针指向子类成员(此时指针类型为基类)//也会调用基类中的成员函数而不是派生类的成员函数
*//*Parent p1;      //基类对象Child c1;       //派生类对象func(p1);func(c1);*/return 0;
}

（仅供参考学习）