C++ 基础语法

1.1

• 常量

const double Pi = 22.0 / 7;

1.2

• 常量表达式

constexpr double GetPi() {return 22.0 / 7;}

constexpr double TwicePi() {return 2 * GetPi;}

1.3.

• 枚举常量，变量只能取一组特定的取值时。

enum Directions{
    north,
    south,
    east,
    west
};

Directions Mydirection = west; // 这个枚举常量只能取前面指定的值

1.4

• 预处理器宏
• 只进行文本替换，编译器不知道变量类型，不推荐。

# define Pi 3.1415

2.1

• 数组：按一定顺序将一系列相同类型的数据存储到内存中
• 定义静态数组：包含的元素数和内存量都是固定的（即使有些元素未使用）

int Manynumbers [5] = {0};  //初始化为相同的值
int Manynumbers [5] = {2, 6, 11, 44, 43}; //初始化为不同的值
int Manynumbers [5] = {19, 12}; //初始化部分值

const int ARRAY_LENGTH = 5;
int Manynumbers [ARRAY_LENGTH] = {10};

• 数组长度定义为常量，需要在多个地方使用时很方便

int Manynumbers [] = {12, 13, 18}; //知道数组每个元素的初始值，可以不指定数组长度

2.2

• 多维数组

int Multiarray [2][3] = {{0, 1, 2}, {3, 4, 5}};
int Multiarray [2][3] = {0, 1, 2, 3, 4, 5};

• 内存是一维的，只是在模拟二维，所以这两种初始化是一样的

2.3

• sizeof运算符查看变量或类型占用内存数（字节数）

sizeof(variable)
sizeof(type)

sizeof(int); //4
sizeof(Manynumbers); //5*4=20

3.1

// switch-case
sitch(expresion){
    case A:
        Do;
        break;
    case B:
        Do;
        break;
    default:
        Do;
        break;
}

3.2

• 三目运算符

int Bignum = (a > b)?a:b;

3.3

• 无限循环与控制无限循环

while(true){
    Do;
    if(expression)
        break;
}

for(;;){
    Do;
    if(expression)
        break;
}

do{}while(); //使用此循环时，

4.1

• 函数原型

double Area(double radius);//类型+函数名+形参列表(函数形参类似于局部变量，只能在函数内部使用)

• 函数定义

double Area(double radius){
    return Pi*radius*radius;
}

• 带默认值的函数形参

double Area(double radius, double Pi = 3.14);

4.2

• 递归函数
• 可以内部调用自己的函数
• 明确的退出条件
• 斐波那契数列， F(0)=0,F(1)=1,F(2)=1,...,F(n)=F(n-1)+F(n-2).

int GetFib(int fibN){
    if(fibN < 2)
        return fibN;
    else
        return GetFib(fibN-1) + Get(fibN-2);
}

4.3

• 函数重载：函数名和返回类型相同，但参数不同的函数

double Area(double radius); //圆形面积

double Area(double radius, double height); //柱体面积

4.4

• 将数组传递给函数

int Mynumbers[] = {12,12,14,32};
void DisplayArray(int numbers[]/int[] numbers, int length){
    for(int index = 0;index<length; ++length)
        cout<<numbers[index]<<endl;
}
DisplayArray(Mynumbers,4);

4.5

• 按引用传递参数

double Area(double radius);

• 当main函数调用该函数时，不会影响main函数里面的radius值，因为Area使用的是包含值的拷贝

double Area(double& radius); //去这个值的地址

5.1

• 指针是一个变量，也占用内存空间，是一种指向内存的特殊变量
• 必须对指针进行初始化，否则包含的值是垃圾值
• 这些垃圾值非常危险，因为它们可能会导致程序访问非法内存单元

int Age = 24;
int* pint = &Age; // 引用运算符& 又称 取地址运算符
cout<<*pint; // 解除引用运算符* 又称 取内容运算符

5.2

• 动态内存分配
• 数组内存分配是静态和固定的，限制了程序的容量，降低了程序的性能

int numbers[100]={0}；

• 使用new来分配新的内存块，如果成功，会得到一个指针指向分配的内存
• new表示请求分配内存，但不总是会得到满足，取决于系统的状态

Type* pointer = new Type;
int* pnumber = new int; //得到指向一个int的指针
int* pnumbers = new int[10] //得到一个指向10个int的指针

• 使用new分配的内存最终都需要使用对应的delete进行释放,否则会导致内存泄漏

delete pnumber;
delete[] pnumbers;

5.3

• 递增递减用于指针
• 包含的地址将增加或减少指向的数据类型的sizeof()

int* pointer = &age;
++pointer = &age + sizeof(int)

5.4

• const用于指针

• const确保变量在整个生命周期都是初始值，不会改变

• 指针指向的值是常量，不能修改，但可以修改指针包含的地址

int Age = 24;
const int* pointer = &Age; //指针指向的内容永远不变，但指针地址可能会变
int height = 180;
pointer = &height //YES
*pointer = height //NO

• 指针指向的地址是常量，不能修改，但可以修改指针指向的内容

int Age = 24;
int* const pointer = &Age; //指针指向的地址永远不变，但指针指向的内容可能会变
int height = 180;
pointer = &height //NO
*pointer = height //YES

5.5

• 数组与指针
• 前面说的递增递减用于指针和这里非常相似

int Mynumbers[5] = {0};
int* Poniters = Mynumbers;
*(Pointers+1) == Mynumbers[1]
// Mynumbers就是一个指针，指向数组的第一个元素Mynumbers[0]

5.6

• 检查new发出的分配请求是否得到了满足
• 使用异常，如果分配失败将会引发bad_alloc异常，程序中断执行。
• 不使用异常，程序将被操作系统终止，显示不友好的界面

int main(){
    try
    {
        int* Age = new int[1000];
        ...
        delete[] Age;
    }
    catch(bad_alloc)
    {
        cout<<"memory allocation failed."<<endl;
    }
    return 0;
}

5.7

int* point = NULL; //point 是个指针，int* 是指针类型

int original = 12;
int& refere = original; //refere 是个引用，是后面变量的别名， int& 是引用类型

*point， &refere 里* &是操作符

const int& refere = original; //仅仅是别名，不能修改原始值

6.1

• 类类似于函数声明，本身并不影响程序的运行，而必须使用它
• 类是一组属性和操作这些属性的函数的集合

class Human
{
    // 属性
    string Name;
    string DateofBirth;
    string PlaceofBirth;
    string Gender;
    
    // 方法
    void introduceself();
    
}

6.2

• 实例化对象，类是蓝图，本身不会有任何影响，对象是类的化身，要使用类的功能，必须实例化对象
• 和创建其他类型类似

int Pi = 3.1415;
Human Tom;

• 动态内存分配也类似

int* pointer = new int[5];
delete* pointer;

Human* phuman = new Human();
delete phuman;

6.3

• 访问类成员
• 属性和方法都是类的成员

Human Tom;
Tom.DateofBirth = "1994";
Tom.introduceself();

Human* PTom = new Human();
PTom->DateofBirth = "1994";
PTom->introduceself();
(*PTom).DateofBirth = "1994";

6.4

• 类能够让设计者控制类的属性的访问和操作的方式

class Human
{
private:
    int Age;
    string Name;

public:
    int GetAge(){
        return Age;  //类内函数可以直接在内部访问类的属性
    }
    
    void SetAge(InputAge){
        Age = InputAge;
    }
}


Human Tom;
Tom.Age = 19; //返回一个错误，无法访问私有成员
// 但可以通过类的函数访问和控制，但这样对于管理者来说，是可控的行为。

6.5

• 构造函数：和类名相同，但没有任何返回值的函数

• 保证实例化对象时，属性成员不会是垃圾值

• 析构函数：与类同名，前面有个波浪号~

• 每将对象不在作用域内或通过delete删除时，都将调用析构函数

• 析构函数不能重载

class Human
{
private:
    int Age;
    string Name;

public:
    Human(){
        Age = 0;
    }
    Human(string HumanName){
        Name = HumanName;
    }
    Human(string HuamnName, int HuamanAge){
        Name = HuamnName;
        Age = HumanAge;
    }
    ~Human(){
        
    }
}

6.6

• this指针包含当前对象的地址，值为&object
• 类成员方法调用其它成员方法或属性时，编译器会隐士传递this指针

class Human
{
private:
    int Age;
    string Name;

public:
    int GetAge(){
        return Age;  //类内函数可以直接在内部访问类的属性
    }
    
    void SetAge(this, InputAge){
        int OriginalAge = GetAge()
        Age = InputAge; // this->Age = InputAge;
    }
}

7.1

• 派生类继承了基类