char *GetMemory(void)
{
    char p[] = "hello world!";
    return p;
}
//上述用法错误
//p是一个数组名，属于局部变量，存储在栈中，在函数结束后，内存被释放，函数返回的指向p的内容也不确定
//p局部变量存储在动态存储区，在函数调用时动态分配内存，调用完成后销毁
// 可以这样修改
//1：
char *p = "hello world!";
return p; //函数返回p存储的地址
//2：
static char p[] = "hello world!";
return p;// 改为静态变量，存储在静态存储去，在程序结束后释放

1.返回值为值类型的函数

int func()
{
    return 1;
}
int i = func();
//有一个临时对象来保存func()函数的返回值1，之后将临时对象的值赋给i。
//编译器将所有的临时对象自动成为const。所以，对于返回值为值类型的函数，其返回值func()为右值。

2.返回值为引用类型的函数

当函数的返回值是引用类型时，其返回值即为return的变量，所以不需要临时对象保存其返回值。所以，对于返回值为引用类型的函数，其返回值为左值。

#include<stdlib.h>
#include<stdio.h>
#include<string>
char& get_val(std::string& str, int index)
{
    return str[index - 1];
}
int main()
{
    std::string str = "12345";
    char ch = get_val(str, 1);
    get_val(str, 1) = 'a';
    printf("ch is %c\n", ch);
    printf("str is %s\n", str.c_str());
    return 0;
}
// 结果
// ch is 1
// str is a2345

3.返回值是const内置类型时

对于返回值是内置类型的函数来说，即使是非const类型，其返回值也不会被修改。无论是否有const修饰，其函数的返回值都是右值。

#include<stdlib.h>
#include<stdio.h>
#include<string>

char get_val(std::string& str, int index)
{
    return str[index - 1];
}

const char get_val2(std::string& str, int index)
{  
return str[index - 1];  
}

int main()
{
    std::string str = "12345";
    char ch = get_val(str, 1);//ch的值是'1'
    get_val(str, 1) = 'a';//编译时报错，expression is not assignable: 左操作数必须为左值
    return 0;
}

4.返回值是自定义类型时

#include<stdlib.h>
#include<stdio.h>
#include<string>

class X {
    int x;
public:
    X(int i = 0);
};
X::X(int ii)
{  
    x = ii;
}
X f1()
{  
    return X();
}  
const X f2()
{  
    return X();
}

int main()
{
    f1() = X(1);//编译时不报错
    f2() = X(1);//error: no viable overloaded '=': 没有找到接受“const X”类型的左操作数的运算符
    return 0;
}
// 函数f1()的返回值是非const类型，所以可以对其返回值进行赋值，即返回值是左值；而f2()的返回值是const类型，则不能对其进行赋值，即返回值是右值。
// 对非const类型的返回值进行赋值，虽然可以编译通过，但是实际上这么做没有意义。因为函数的返回值保存在临时对象中，我们无法访问该临时对象，在该行代码执行完毕后，临时对象就会被清除。

指向常量的指针

指向常量的指针不能用于改变其所指向对象的值。想要存放常量对象的地址，只能使用指向常量的指针。

const double pi = 3.14;
double *ptr = π//错误，ptr是非const指针
const double *cptr = π//正确

常量指针

常量指针的本身是常量，必须初始化，而且一旦初始化，则它本身的值就不会改变。

int errNumb = 0;
int* const curErr = &errNumb;//curErr是常量指针，且一直指向errNumb

指向常量的常量指针
指向常量的常量指针指向一个常量对象，且该指针本身也是常量。

const double* const pip = π

const char* get_string()
{
    return "12345";
}
// 函数get_string()返回从字符串字面值中建立的const char*。在编译器建立了该字符串并且将其存储在静态存储区之后，该返回值返回的是该字符串字面值在静态存储区中的地址。
// 所以get_string()函数的返回值是右值，且不能为非const指针赋值。

get_string()[0] = 'a'; //错误，表达式必须是可修改的左值
char* pstring = get_string();//错误，“const char*”类型不能用于初始化“char*”类型的实体
const char* cpstring = get_string();//正确
// 另外还需要注意的是，函数不能返回指向局部栈变量的指针，因为栈变量在函数返回后就销毁了，其返回的地址为无效地址。

// 将“5返回值是指向常量的指针的函数”中提到的get_string()const char* const get_string()  
const char* const get_string()  
{  
     return "12345";
}

// 因为该返回值是指向常量的，所以像在“5返回值是指向常量的指针的函数”中提到的一样，该值为右值，不能对其进行赋值，也不能将其赋值给非const指针。
// const char* const ccpstring = get_string();//正确
// const char* cpstring = get_string();//正确
// 从上面代码可知，指向常量的常量指针可以赋值给指向常量的非常量指针

#include <> :按系统指定的目录检索,常用于包含库函数的头文件,用#include ""也能找到，但增加了编译时间
#include "":常用于包含自定义的头文件。先在.cpp文件所在目录去搜索包含的.h文件，用#include <>也能找到，但增加了编译时间
./ 是当前目录
../ 是父级目录
/ 是根目录

// 预编译宏
#ifndef XXXXX_H
#define XXXXX_H
#endif
// 作用是防止被重复引用

因为函数被C++编译后在symbol库中的名字与c语言不同。
例如void fun(int x, int y);
C编译器编译后在symbol库中的名字为_fun，C++编译器则会产生像_fun_int_int之类的名字。_fun_int_int这种名字包含了函数名和函数参数数量及类型信息，C++就是靠这种机制来实现函数重载的。
为了实现C和C++的混合编程，C++提供了C连接交换指定符号extern "C"来解决名字匹配问题,实现C++代码调用其他C语言代码。

#ifdef __cplusplus // 告诉编译器，如果定义了__cplusplus(即如果是cpp文件,因为cpp文件默认定义了该宏)，
extern "C"{ // 告诉编译器，这部分代码按C语言的格式进行编译，而不是C++的
#endif
/*…*/
#ifdef __cplusplus
}
#endif

#define　宏名　一段符号
示例：#define PI 3.141926

为什么使用宏定义？
方便修改和管理，不用一个一个的去改，也是一种参数化的思想。宏定义不作语法检查，只有在编译被宏展开后的源程序才会报错，注意如果是表达式，一定用要用括号括起来。

C编译器，提供了几个特殊形式的预定义宏，在实际编程中可以直接使用，很方便。

__FILE__ 宏所在文件的源文件名
__FUNCTION__ 宏所在函数名
__LINE__ 宏所在行的行号
__DATE__ 代码编译的日期
__TIME__ 代码编译的时间