#include <iostream>
#include <string>


using namespace std;



/* 内存分配模型 */
// 代码区：存放函数体的二进制代码，由OS进行管理；
// 全局区：存在全局变量及静态变量、常量；
// stack：由编译器自动分配与释放，存放函数的参数、局部变量
// heap：由程序员自己分配与释放，若程序员不释放，在程序结束时OS会自动回收


// 全局变量
int g_a = 100;
int g_b = 1000;

// 全局常量
const int c_g_a = 100;
const int c_g_b = 1000;


int* func() {
    int a = 10;
    return &a;  // 不要返回局部变量的地址
}


int* func1() {
    int *a = new int(10);
    return a;
}


// 引用传递:形参的修改会影响实参，效果同地址传递
void swap1(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

// 引用作为函数返回值
int& bar() {
    int a = 99;  // 局部变量
    return a;   // 返回局部变量的引用
}

int& foo() {
    static int b = 199;
    return b;  // 返回静态变量的引用
}


void func11(int& ref) {
    ref = 19999;
}


// 常量引用：用了修饰形参，防止误操作
void showValue(const int& v) {
    cout << v << endl;
}


// 函数重载：同一个作用域下，函数名相同，函数参数类型或参数个数或参数顺序不同，与返回值类型无关
void showHello() {
    cout << "hello\n" << endl;
}

void showHello(int a) {
    cout << "hello" << a << endl;
}

void showHello(int a, float b) {
    cout << "hello" << a << b << endl;
}

void showHello(float a, int b) {
    cout << "hello" << a << b << endl;
}

// 函数返回值不同，不可以作为函数重载条件
#if 0
int showHello(float a, int b) {
    return a + b;
}
#endif



int main() {

    #if 0
    // 局部变量
    int a = 100;
    int b = 1000;

    // 局部常量存放在stack
    const int l_a = 100;
    const int l_b = 1000;

    cout << "局部变量a的地址:" << (int)&a << endl;
    cout << "局部变量b的地址:" << (int)&b << endl;

    // 全局变量存放在全局区
    cout << "全局变量g_a的地址:" << (int)&g_a << endl;
    cout << "全局变量g_b的地址:" << (int)&g_b << endl;

    // 全局常量存放在全局区
    cout << "全局常量c_g_a的地址:" << (int)&c_g_a << endl;
    cout << "全局常量c_g_b的地址:" << (int)&c_g_b << endl;

    // 局部常量存放在stack
    //cout << "局部常量l_a的地址:" << (int)&l_a << endl;
    //cout << "局部常量l_b的地址:" << (int)&l_b << endl;


    // 静态变量存放在全局区
    static int s_a = 100;
    static int s_b = 1000;
    cout << "静态变量s_a的地址:" << (int)&s_a << endl;
    cout << "静态变量s_b的地址:" << (int)&s_b << endl;
    


    int *p = func();
    cout << *p << endl;
    cout << *p << endl;
    #endif

    int *p = func1();
    cout << *p << endl;
    cout << *p << endl;

    delete p;  // 手动释放heap区数据
    


    int* arr = new int[10];

    for(int i = 0; i  < 10; i++) {
        arr[i] = i + 100;
    }

    for(int i = 0; i < 10; i++) {
        cout << arr[i] << endl;
    }

    delete[] arr;  // 手动释放heap上动态申请的数组





    int aa = 666;
    int bb = 777;

    int& r_aa = aa;  // r_aa是变量aa的引用,引用必须初始化

    // int& r_aa = bb;  引用在初始化后，不可以改变即不可以修改引用绑定的对象

    r_aa = bb;   // 这是赋值操作，不是修改引用
    r_aa = 9999;

    cout << "aa = " << aa << endl;
    cout << "r_aa = " << r_aa << endl;


    aa = 666;
    bb = 777;

    cout << "aa = " << aa << endl;
    cout << "bb = " << bb << endl;
    swap1(aa, bb);
    cout << "aa = " << aa << endl;
    cout << "bb = " << bb << endl;


    // int& ref = bar(); 不能返回局部变量的引用
    // cout << "ref = " << ref << endl;

    int& ref = foo(); 
    cout << "ref = " << ref << endl;

    // 函数调用作为左值,则函数必须返回引用
    foo() = 100;
    cout << "ref = " << ref << endl;



    // 引用的本质：内部实现是一个指针常量
    // int* const ref = &a;

    ref = 2000;  // *ref = 200;
    func11(ref);

    // 常量引用
    const int& ref_a = 10;  // 等于int temp = 10; const int&　ref_a = temp;
    
    // ref_a = 1024; 错误，加入了const进行了修饰后，变量不可以被修改

    // 函数中利用常量引用防止误操作修改实参
    showValue(ref_a);


    
    
    return 0;
}