C++基础篇（2）（下）

类型 &引用名 = 原变量名;

#include <iostream>
using namespace std;
int main() {
  int a = 520;
  int& b = a;
  int& c = a;
  int& d = b;
  ++d;
// 引⽤：b和c是a的别名
  cout << &a << endl;
  cout << &b << endl;
  cout << &c << endl;
// 也可以给别名b取别名，d相当于还是a的别名
  cout << &d << endl;
//地址，值都是一样的
  cout << a << endl;
  cout << b << endl;
  cout << c << endl;
  cout << d << endl;
  return 0;
}

#include<iostream>
using namespace std;
int main()
{
  int a = 10;
  // 编译报错：“ra”: 必须初始化引⽤
  //int& ra;
  int& b = a;
  int c = 20;
  // 这⾥并⾮让b引⽤c，因为C++引⽤不能改变指向，
  // 这⾥是⼀个赋值
  b = c;
  cout << a << endl;
  cout << b << endl;
  cout << c << endl;
  b = 30;
  cout << &a << endl;
  cout << &b << endl;
  cout << &c << endl;
  cout << a << endl;
  cout << b << endl;
  cout << c << endl;
  return 0;
}

#include <iostream>
using namespace std;
void Swap(int& x, int& y) {
  int temp = x;
  x = y;
  y = temp;
}
int main() {
  int x = 520, y = 1314;
  cout << x << " " << y << endl;
  Swap(x, y);
  cout << x << " " << y << endl;
 
  return 0;
}

#include<iostream>
#include <assert.h>
#include <stdlib.h> 
 
using namespace std;
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 = 0; // 栈顶初始化为 0，表示栈为空
    rs.capacity = n;
}
 
void STPush(ST& rs, STDataType x) {
    // 满了，扩容
    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; 
    rs.top++; // 栈顶指针上移
}
 
int& STTop(ST& rs) {
    assert(rs.top > 0); // 确保栈不为空
    return rs.a[rs.top - 1]; // 返回栈顶元素的引用
}
 
int main() {
    ST st1;
    STInit(st1);
    STPush(st1, 1);
    STPush(st1, 2);
    cout << STTop(st1) << endl; // 输出栈顶元素 2
    STTop(st1) += 10; // 通过引用修改栈顶元素
    cout << STTop(st1) << endl; // 输出修改后的栈顶元素 12
    return 0;
}

const 类型 &引用名 = 引用的对象;

int main()
{
const int a = 10;
// 编译报错：error C2440: “初始化”: ⽆法从“const int”转换为“int &”
// 这⾥的引⽤是对a访问权限的放⼤
//int& ra = a;
// 这样才可以
const int& ra = a;
// 编译报错：error C3892: “ra”: 不能给常量赋值
//ra++;
// 这⾥的引⽤是对b访问权限的缩⼩
int b = 20;
const int& rb = b;
// 编译报错：error C3892: “rb”: 不能给常量赋值
//rb++;
return 0;
}

#include<iostream>
using namespace std;
int main()
{
int a = 10;
const int& ra = 30;
// 编译报错: “初始化”: ⽆法从“int”转换为“int &”
// int& rb = a * 3;
const int& rb = a*3;
double d = 12.34;
// 编译报错：“初始化”: ⽆法从“double”转换为“int &”
// int& rd = d;
const int& rd = d;
return 0;
}

#include <iostream>
using namespace std;
 
void print(const int& x) {
    cout << x << endl;
    // x = 5; // 错误：不能通过 const 引用修改对象
}
 
int main() {
    int a = 10;
    const int& ref = a; // 创建一个对 a 的 const 引用
    // ref = 20; // 错误：不能通过 const 引用修改对象
 
    print(a); // 正确：传递 int
    print(20); // 正确：传递字面量，通过 const 引用允许
 
    return 0;
}