int fun(int a, int b, int c)
{
    cout << a << endl;
    cout << b << endl;
    cout << c << endl;
    return 0;
}

int fun(int a, int b, int c = 10)
{
    cout << a << endl;//<<为输出运算符。
    cout << b << endl;
    cout << c << endl;
    return 0;
}
int main()
{
    int a = 1;
    int b = 2;
    fun(a,b);
    //知识点：函数的默认值参数：如果不传c，则填充默认值，push 0Ah，其他的参数push eax。
    //在函数声明或者定义的时候给定参数默认值；如果实参传递的时候不给该形参传值，则会按照默认值传参。
    //函数的默认值参数 是在编译期，生成指令的时候，直接生成入参指令。
    //函数参数默认值不能传递变量，必须是常量。因为变量在编译期时无法取值。
    return 0;
}

//以下情况不可以，在调用此函数时，会出现歧义。因此编译器不能通过。
//函数的参数只能从右向左依次连续赋值，不能跳过
int fun(int a, int b = 10, int c)
{
    cout << a << endl;
    cout << b << endl;
    cout << c << endl;
    return 0;
}

//但是如下代码可以运行，结果为1, 10, 20.
//相当于fun函数在定义时定义c的默认值为20，在声明时定义b的默认值为10。
int fun(int a, int b, int c = 20)
{
    cout << a << endl;//<<为输出运算符。
    cout << b << endl;
    cout << c << endl;
    return 0;
}
int fun(int a, int b = 10, int c);
int main()
{
    int a1=1;
    fun(a1);
}

//错误，函数的默认值参数在同一作用域只能赋值一次，不能重复给相同的一个参数赋值。
int fun(int a, int b, int c = 20)
{
    cout << a << endl;//<<为输出运算符。
    cout << b << endl;
    cout << c << endl;
    return 0;
}
int fun(int a, int b, int c = 30);
//无法运行，提示参数默认值重定义赋值。

//不可行。编译是针对单文件的，所以不能知道在其他文件函数中定义的函数参数默认值
#fun.cpp
int fun(int a, int b, int c = 20)
{
    cout << a << endl;
    cout << b << endl;
    cout << c << endl;
    return 0;
}
#main.cpp
int fun(int a, int b, int c);
int main()
{
    int a1 = 1;
    int b1 = 2;
    fun(a1,b1);
    return 0;
}

inline int fun1(int a, int b)
{
    int c = a + b;
    cout << c << endl;
    return c;
}
int main()
{
    int a1 = 1;
    int b1 = 2;
    fun1(a1,b1);
    return 0;
}

inline int fun1(int a, int b)
{
    fun1(a,b);
    //不报错，只警告
}

//c语言的写法
bool compare1(int a, int b)
{
    return a > b;
}
bool compare2(char a, char b)
{
    return a > b;
}
int main()
{
    int a1 = 1;
    int b1 = 2;
    
    char a2 = 'c';
    char b2 = 'b';
    
    compare1(a1,b1);
    compare2(a2,b2);
}

bool compare(int a, int b)
{
    cout << "bool compare(int a, int b)" << endl;
}
bool compare(char a, char b)
{
    cout << "bool compare(char a, char b)" << endl;
}

//可以运行，因为虽然main中只是声明，但是会生成UND符号，会寻找链接。
#fun.cpp
bool compare(int a, int b)
{
    cout << "bool compare(int a, int b)" << endl;
}
bool compare(char a, char b)
{
    cout << "bool compare(char a, char b)" << endl;
}
#main.cpp
bool compare(int a, int b);//*UND*
bool compare(char a, char b);
int main()
{
    int a1 = 1;
    int b1 = 2;
    
    char a2 = 'c';
    char b2 = 'b';
    
    compare1(a1,b1);
    compare2(a2,b2);
}

#fun.cpp
void fun_CPP()//生成的符号：fun_CPP_void
{
    printf("void fun_CPP()");
}

#func.c
void fun_CPP();//生成的符号：fun_CPP
int main()
{
    fun_CPP();
    return 0;
}

//C调用C++的代码方法
------------------------------------------
#fun.cpp
int fun_CPP(int a)//生成Cpp符号：fun_CPP_int
{
    printf("int fun_CPP(int a)");
    return a;
}
------------------------------------------
#tmp.cpp
void fun_CPP();			//声明
extern "C"
{
    int fun_CPP_tmp(int a)	//要与fun_CPP形式一致
    {
        return fun_CPP(a);
    }
}
-----------------------------------------
#func.c
int fun_CPP_tmp(int a);//生成C符号：fun_CPP
int main()
{
    int n = 100;
    int res = fun_CPP_tmp(100);
    return 0;
}

//tmp.h
namespace AA
{
    typedef int INT;
    typename char CHAR;
}

#include<iostream>
using namespace AA;
int main()
{
    INT a = 10;//需要使用命名空间AA才能编译通过。
    return 0;
}

using AA::INT;//拿出命名空间中特定的某一个使用。

//fun.cpp
int arr[]={0,1,2,3,4,5,6,7,8,9};

using AA::INT;
extern int* arr;
/*
指针和数组名的区别——什么是指针
*/
int main()
{
    cout << arr << endl;		//
    cout << *arr << endl;	//
    cout << arr[0] << endl;
}
//输出00000000\n 崩溃
int main()
{
    int a = 10;
    int *p = &a;
    int arr1[]={0,1,2,3,4};
    
    cout << arr1 <<endl;
    cout << p <<endl;
    //输出的都是数组的地址，正常
    //汇编代码：
    //1. lea eax,[arr1];  push eax。直接传值给eax
    //2. mov eax,dword ptr [p];  push eax。有dword ptr，去地址中取值
    ///////
    //数组名就是个地址。本质是常量，是个数字
    //指针是变量。
    
    
    
    
    //在编译时，直接把常量的值替换了常量名字。
    
}
//变量和常量有何区别？
int main()
{
    int a = 20;
    int *p = &a;
    int b;
    b = 20;
    b = a;
    //用常量给变量赋值时，直接拿值替换。
    //用变量给变量赋值时，有一次解引用
    
    b = *p;//去p的内存中将存储的地址拿出来。再去拿出来的地址中取出存储的数据。
    //汇编：
    // mov eax,dword ptr [p]
    // mov ecx,dword ptr [eax]
    // mov dword ptr [b],ecx
}
/*
回到最初的问题，我们把arr当作了指针，把常量当作了变量来用。
常量不用下地址，变量需要下地址。
如果把常量当作了变量来用，编译器会将解引用，把解引用到的数据（数组首元素）当作结果来输出了。即00000000
cout << arr << endl;
mov eax,dword [arr]
mov out,eax
*/

//c_main.c
#include<stdio.h>
int main()
{
    const int a = 10;
    a = 20;//报错，必须是可修改的左值。
    
    int *p = &a;
    *p = 20;
    
    
    printf("%d\n",a);
    
    return 0;
}

int main()
{
    const int a = 10;
    //a = 20;
    //int *p = &a;
    cout << a <<endl;
    cout << *p <<endl;
    // 10 10
    
    *p = 20;
    cout << a <<endl;
    cout << *p <<endl;
    //10 20
    //C++中，const常量就是纯常量，而不像C语言中可以轻易通过指针间接修改的。
    //mov out, 0Ah ; cout << a
    //常量：在编译期，将常量的值直接传入到目标中。
}

int main()
{
    int *p1 = &a;
    const int *p2 = &a;
    int const* p3 = &a;
    int* const p4 = &a;
    
    int *q1 = &a;
    const int* q2 = &a;
    int const* q3 = &a;
    int* const q4 = &a;
}

int fun(int a)
{
    cout << typeid(a).name() << endl;
    return 0;
}
int fun(const int a)
{
    cout << typeid(a).name() << endl;
    return 0;
}

int main()
{
    int *p = new int;
    *p = 10;
    delete p;
    
    int *arr = new int[10];
    arr[0] = 10;
    delete[]arr;//释放数组
}

int main()
{
    int **arr1 = new int* [4];
    for(int i = 0;i<4;i++)
    {
        arr1[i] = new int[5];
    }
    for(int i =0;i<4;i++)
    {
        delete[]arr1[i];
    }
}

int *pa = (int*)::operator new(sizeof(int));
new(pa) int(10);//不开辟空间，而是用int(10)去初始化pa指向的空间。

int main()
{
    int a = 10;
    int& b = a;
    
    
    b = 20;//  mov eax,dword ptr [b]
    cout << a <<endl;
    cout << b <<endl;
	// 20 20

	int *p = &a;
    *p = 20;
}

int main()
{
    const int c = 20;
    int& d = c;//报错
    const int& d = c;
}

int fun1()
{
    return 10;
}

int main()
{
    int& e = fun1();//报错，不能引用寄存器
    const int& e = fun1();
    
    const int& f = 10;
    
    //当引用一个不可取地址的量的时候，使用常引用
    //会生成一个临时量，实际引用的是这个临时量。
    //为什么必须要const来修饰临时量？因为临时量都有常属性。（关于临时量，面向对象还会涉及。
}

int a=10;
int &b=a;
const int& c = b;

int flag = 0;
void echo()
{
    if(0 == flag)
    {
    	printf("%s\n","printf screen");
    }
    else
    {
        printf("%s\n","printf file");
    }
}
void set_flag_file()
{
    flag = 1;
}
void set_flag_screen()
{
    flag = 0;
}

class Note
{
public:
    Note()
    {
        _flag = 0;
    }
    void echo()
    {
        if(0 == _flag)
        {
            printf("%s\n","printf screen");
        }
        else
        {
            printf("%s\n","printf file");
        }
    }
    void set_flag_file()
    {
        _flag = 1;
    }
    void set_flag_screen()
    {
        _flag = 0;
    }
private:
    int _flag;
}
int main()
{
    Note n;
    n.echo();
    n.set_flag_file();
    n.echo();
    
    
    return 0;
}