初识c++

//c++
void Swap(int& rx, int& ry)
{int tmp = rx;rx = ry;ry = tmp;
}
//c
void Swap(int* px, int* py)
{int tmp = *px;*px = *py;*py = tmp;
}
int main()
{int a = 10;int b = 20;Swap(&a, &b);//cSwap(a, b);//c++return 0;
}

引用可以避免指针的一些复杂操作，同时提高的程序的效率

对于用c写的函数传参的时候实参拷贝给形参，因此程序会开辟一块空间来储存形参。

对于c++写的函数此时函数的参数就是实参的别名，因此不会开辟空间

6.3.2引用做返回值

以栈来举例

typedef int STDataType;
typedef struct Stack
{STDataType* a;int top;int capacity;
}ST;void STInit(ST& rs, int n = 4)
{rs.a = (STDataType*)malloc(n * sizeof(STDataType));rs.top = -1;rs.capacity = n;
}// 栈顶
void STPush(ST& rs, STDataType x)
{//assert(ps);// 满了， 扩容if (rs.top == rs.capacity){printf("扩容\n");int newcapacity = rs.capacity == 0 ? 4 : rs.capacity * 2;STDataType* tmp = (STDataType*)realloc(rs.a, newcapacity *sizeof(STDataType));if (tmp == NULL){perror("realloc fail");return;}rs.a = tmp;rs.capacity = newcapacity;}rs.a[++rs.top] = x;
}
// int STTop(ST& rs)
int& STTop1(ST& rs)
{assert(rs.top > 0);return rs.a[rs.top];
}
int STTop2(ST& rs)
{assert(rs.top > 0);return rs.a[rs.top];
}
int main()
{ST st1;STInit(st1);STPush(st1, 1);STPush(st1, 2);STTop1(st1) = 10;STTop2(st1) = 20;//编译报错，表达式必须是可修改的左值return 0;
}

也就是说STTop2(st1)不能被修改，为什么STTop1(st1)可以被修改，此时就要涉及到临时变量

当函数返回一个数据类型（int）时，会生成一个临时变量，返回的值会拷贝给临时变量，而临时对象作为这个函数的返回值，而临时对象具有常性（不能被修改），因此STTop2(st1)不能被修改

对于函数返回的是引用来说，则不会生成临时变量

STTop1(st1)=10,修改的就是rs.[rs.top]的值；

如果返回的引用是函数体内的变量，就会导致和野指针类似的问题

int& fun()
{int a = 10;return a;
}

int main()
{const int a = 10;//int& ra = a; 这⾥的引⽤是对a访问权限的放⼤,const int a只能被读，不能被写（修改）// 如果用int&就会导致a可读可写,权限放大// 这样才可以const int& ra = a;// 这⾥的引⽤是对b访问权限的缩⼩int b = 20;const int& rb = b;//rb++;此时rb不能被修改，但是b可以被修改b++;return 0;
}

int main()
{double b = 1.12;const int& rb = b;//类型转换也会生成临时变量int a = 2;const int& rd = a * 3;//表达式的结果保存在临时对象里//从上面可以推测const引用可以引用常量const int& rc = 10;return 0;
}

#define ADD(a, b) ((a) + (b))
inline int Add(int a, int b)
{return a + b;
}
int main()
{int ret = ADD(1, 2);cout << ADD(1, 2) << endl;int x = 1, y = 2;Add(x, y);return 0;
}

如果用宏的话，很多细节可能会注意不到，而用inline就不用但心一些细节问题