int a; int &b = a;
#include
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改为50
int &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 << " " <
#include
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
template 的含义是"模板",
<>中先写关键字 typename 或 class ,后边跟一个类型参数
XXX,类似标识符, 是一个虚拟的类型名
/* 开辟一个存放整型的存储空间,返回一个指向该存储空间的地址(指针) */
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
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; //100
cout << *q << endl; //50
int *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
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 <
myclass.h:
#ifndef MYCLASS_H
#define MYCLASS_H
#include
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 <name; //在普通成员函数内可以使用this
}
static int num; //静态成员变量
static void static_func(){
//cout << this << endl; //静态成员函数中不能使用this
cout << "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; //80
cout << myclass::num++ << endl; //81
cout << myclass::num << endl; //82
return 0;
}
#include
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;
}
(仅供参考学习)