CPP

类

1. 最简单的类定义：

#include <iostream>
using std::cout;
using std::endl;
class Box{
//    默认访问权限为private
    int a=3;
    int b=5;
public:
    int c=9;    
    int getA(){
        return a;
    }
};
int main() {
    Box b;
    cout<<b.getA()<<endl;
    cout<<b.c<<endl;
    //cout<<b.a<<endl//错误，不能访问私有成员
    return 0;
}

类访问修饰符

标记	在类内部使用	继承时使用
public	公有成员，在程序中类的外部是可以被访问的。你可以不使用任何成员函数来设置和获取公有成员变量的值	public继承，基类成员的访问权限在派生类中不发生变化（变化与否同事体现在类内部对父类成员的使用与子类对象对父类成员的使用）
private	私有成员，只有类和友元函数可以访问	private继承，基类成员的权限全部变成private
protected	保护成员，与私有成员类似，但保护成员可以在派生类中被访问	protected继承，基类的public类型成员权限变成protected，其他权限类型成员权限不变。

1. 子类以某种权限继承父类，这种权限的作用范围为使用到子类的对象。也即是说，无论以什么权限继承，在子类的内部成员的眼中，父类成员的权限是没有任何变化的。但是在子类的外部，如子类的一个对象，或者是继承了子类的其他类。这些对象眼中父类成员的权限是经过继承时访问修饰符按照权限更改规则更改过的。

class father{
public:
    int a;
protected:
    int b;
private:
    int c;
}
class pro:public father{
    //在当前类的作用域中
    //a为public,可调用
    //b为protected,可调用
    //c为private，不可调用
}
pro p;
在类pro的对象p眼中：
//a为public,可调用
//b为protected,不可调用
//c为private，不可调用
class pro:protected father{
    //在当前类的作用域中
    //a为public,可调用
    //b为protected,可调用
    //c为private，不可调用
}
pro p1;
在类pro对象p1眼中：
//a为protected,不可调用
//b为protected,不可调用
//c为private，不可调用
class pri:private father{
    //在当前类的作用域中
    //a为public,可调用
    //b为protected,可调用
    //c为private，不可调用
}
pri p2;
在类pri对象p2眼中：
//a为private,不可调用
//b为private,不可调用
//c为private，不可调用

class c1:public pub{
    //在当前类的作用域中
    //a为public,可调用
    //b为protected,可调用
    //c为private，不可调用
}
class c2:public pro{
    //a为protected,可调用
    //b为protected,可调用
    //c为private，不可调用
}
class c3:private pri{
    //a为private,不可调用
    //b为private,不可调用
    //c为private，不可调用
}

构造函数

1. 类构造函数在每次创建类的对象的时候都会被执行。作用是完成类对象的初始化。
2. 构造函数的名字与类的名字完全相同。
3. 构造函数不会返回任何类型，也不会返回void。
4. 初始化类成员的方式：
   
   • 使用初始化列表
   • 在构造函数题内进行赋值操作

#include <iostream>
using std::cout;
using std::endl;
class Box{
public:
    int pub;
    Box(int pub,int pro,int pri);
    ~Box();
    void print(){
        cout<<pub<<endl;
        cout<<pro<<endl;
        cout<<pri<<endl;
    }
protected:
    int pro;
private:
    int pri;
};

Box::Box(int pub, int pro, int pri) {
    this->pub=pub;
    this->pro=pro;
    this->pri=pri;
}

Box::~Box() {
    cout<<"has all delete"<<endl;
}

int main() {
    Box box(1,2,3);
    box.print();
    return 0;
}

析构函数

1. 析构函数会在每次删除所创建的对象的时候执行
2. 析构函数有助于在跳出程序前释放资源。

拷贝构造函数

1. 是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。
2. 拷贝函数通常用于：
   
   • 通过使用同类型的对象来初始化新创建的对象。
   • 复制对象，把它作为参数传递给函数
   • 复制对象，并从函数返回这个对象

友元函数

1. 定义在类的外部，但是有权访问类的所有私有成员和保护成员。
2. 友元函数是一个函数，这个函数被称为友元函数；友元函数也可以是一个类，该类被称为友元类，在这种情况下，整个类及其所有成员都是友元。
3. 使用关键字friend声明一个类的友元。

内联函数

1. 使用关键字inline声明函数

C++ this指针

1. 每一个对象都可以通过this指针来访问自己的地址。this指针是所有成员函数的隐含参数。

C++ 指向类的指针

1. 一个指向C++类的指针与指向结构的指针类似，访问指向类的指针的承运啊。需要使用成员访问运算符->.

C++ 类的静态成员

1. 当我们声明类的成员为静态时，这意味着无论创建多少个类的对象，静态成员都只有一个副本。

继承

访问控制和继承

文件IO

1. 读文件

//
// Created by sf on 11/8/17.
//
#include <iostream>
#include <fstream>
#include <string>
#include <zconf.h>

using std::cout;
using std::endl;
using std::fstream;
using std::ofstream;
using std::ifstream;
using std::string;

#ifndef LEXICAL_ANALYZER_LEXICAL_H
#define LEXICAL_ANALYZER_LEXICAL_H


class Lexical {
private:
//    读取缓冲区的大小
    const static int SIZE=10;

//    缓冲区A
char buffer_A[SIZE];
//    缓冲区B
char buffer_B[SIZE];
//    需要进行词法分析的源文件
    ifstream inFile;
//    分析结果保存的位置
    ofstream outFile;
public:
    Lexical(string inFileName,string outFileName){

        inFile.open(inFileName,ifstream::in);
        outFile.open(outFileName);

    }
    void testRead(){
    while(!inFile.eof()) {//读取文件结束的时候并不会有相应的效果
        inFile.getline(buffer_A,SIZE,'\n');//从文件中读取，一次读取到5个字符或者遇到\n的时候的截断，放入到buffer中
        cout << buffer_A << endl;
    }

    }
    ~Lexical(){
        inFile.close();
        outFile.close();
        cout<<"关闭文件成功"<<endl;
    }

};


#endif //LEXICAL_ANALYZER_LEXICAL_H