C++进阶语法之函数和指针【学习笔记（二）】

news2024/9/24 7:25:07

文章目录

      • 1、C++ 函数
        • 1.1 函数的定义
        • 1.2 函数原型（function prototypes）
        • 1.3 参数（parameter）——值传递（pass by value）
        • 1.4 重载（overloading）
        • 1.5 函数传参——传递数组（array）
        • 1.6 函数的传参——引⽤传递（pass by reference）
        • 1.7 函数的传参——vector Demo
        • 1.8 函数调⽤机制
      • 2、C++ 指针（pointer）
        • 2.1 指针（pointer）介绍
        • 2.2 指针的解引⽤（dereference）
        • 2.3 动态内存分配（dynamic memory allocation）
        • 2.4 指针和数组的关系
        • 2.5 const和指针
        • 2.6 函数指针传参
        • 2.7 函数返回指针
        • 2.8 指针、引⽤对⽐——回顾⼀下引⽤（reference）

1、C++ 函数

什么是函数？

• C++ 程序
• ---->C++ 标准库（functions 和 classes）
• ---->第三⽅库（functions 和classes）
• ---->⾃定义的functions 和 classes

• 函数让我们的程序更加模块化
• ---->让代码解耦，分成按业务，按逻辑的单元
• ----> 提⾼代码复⽤性

如下图中可以用右图的3个函数语句来实现左图10个语句，
在这里插入图片描述

左图3个函数的实现过程如右图，
在这里插入图片描述

1.1 函数的定义

• 函数名称
• 参数列表
-----> 传给函数的变量
-----> 变量类型需声明
• 返回值类型
• 函数体
-----> 函数被调⽤执⾏的部分
-----> 花括号 { }内部

A、函数的定义——⽆参数
在这里插入图片描述
B、 函数的定义——1个参数
在这里插入图片描述

C、函数的定义——⽆返回类型
在这里插入图片描述
D、 函数的定义——多个参数
在这里插入图片描述
E、函数的定义——函数的调⽤（calling）
在这里插入图片描述

在这里插入图片描述

代码：

#include <iostream>
#include <cmath>

using namespace std;

const double pi {3.1415926};

double calculate_area(double radius){
    return pi * pow(radius, 2);
}
void circle_area(){
    cout << "请输入圆的半径：";
    double radius {};
    cin >> radius;
    cout << "圆的面积是" << calculate_area(radius) << endl;
}
int main()
{
    // 计算圆的面积
    circle_area();

    return 0;
}
1.2 函数原型（function prototypes）

编译器要求：使⽤函数前必须“⻅过”这个函数
• 先定义函数再调⽤
----->• 适⽤于⼩型程序，不适⽤于⼤型项⽬
• 使⽤函数原型
----->• 告诉编译器函数定义必要的信息
----->• 也称为前向声明（forward declaration）
----->• 放在程序开始的部分，在#include之后
----->• 或者放在头⽂件(header files)（.h）中

在这里插入图片描述

函数原型中的参数可以写参数名称也可以不写参数名称，因为编译器关注的是参数类型，
在这里插入图片描述

代码：

先定义函数原型，再编译就不会报错

#include <iostream>
#include <cmath>

using namespace std;

const double pi {3.1415926};

// 定义函数原型
void circle_area();
double calculate_area(double);

int main()
{
    // 计算圆的面积
    circle_area();

    return 0;
}

double calculate_area(double radius){
    return pi * pow(radius, 2);
}
void circle_area(){
    cout << "请输入圆的半径：";
    double radius {};
    cin >> radius;
    cout << "圆的面积是" << calculate_area(radius) << endl;
}
1.3 参数（parameter）——值传递（pass by value）

• 当我们传递数据给函数时，其实⽤的是值传递（pass by value）
• 数据的拷⻉会传给函数
• 函数内部的代码不会改变我们传给它的变量

• 形参（formal parameters）与实参（actual parameters）：
------>• 形参（formal parameters）：函数定义语句中的参数
------>• 实参（actual parameters）：调⽤函数时传递的参数（arguments）

在这里插入图片描述

代码：

#include <iostream>
#include <string>
#include <vector>

using namespace std;

// 函数原型
void change_num(int num);
void change_string(string str);
void change_vector(vector <string> vec);
void print_vector(vector <string> vec);

// 函数定义
void change_num(int num)
{
    num = 1000;
    cout << "在change_num函数中，num的值是" << num << endl;
}

void change_string(string str)
{
    str = "World";
    cout << "在change_string函数中，str的值是" << str << endl;
}

void change_vector(vector <string> vec){
    vec.clear(); // 清空vector
}
void print_vector(vector <string> vec){
    for (auto s: vec){
        cout << s << " ";
    }
    cout << endl;
}

// 主函数
int main()
{
    cout << "====================" << endl;
    int my_num {10};
    cout << "调用change_num函数前，my_num的值是" << my_num << endl;
    change_num(my_num);
    cout << "调用change_num函数后，my_num的值是" << my_num << endl;


    cout << "====================" << endl;
    string my_string {"Hello"};
    cout << "调用change_string函数前，my_string的值是" << my_string << endl;
    change_string(my_string);
    cout << "调用change_string函数后，my_string的值是" << my_string << endl;


    cout << "====================" << endl;
    vector <string> my_vector {"Hello", "World", "computer", "vision"};
    cout << "调用change_vector函数前，my_vector的值是：" ;
    print_vector(my_vector);

    change_vector(my_vector);
    cout << "调用change_vector函数后，my_vector的值是：" ;
    print_vector(my_vector);

    return 0;
}
1.4 重载（overloading）

⼀组函数具有相同函数名，不同参数列表

在这里插入图片描述

在这里插入图片描述

代码：

#include <iostream>
#include <string>
#include <vector>

using namespace std;

void demo_print(int); // 打印整数
void demo_print(double); // 打印浮点数
void demo_print(string); // 打印1个字符串
void demo_print(string, string); // 打印2个字符串
void demo_print(vector <string>); // 打印字符串向量


int main()
{   
    // 函数重载示例，打印不同类型的数据
    demo_print(100);
    demo_print(123.456); //double
    demo_print(123.5f); // float
    demo_print('A'); // 会被转换为整数ascii码
    demo_print("C style string"); // c-style string 被转换为string

    string s {"C++ string"}; // C++ string
    demo_print(s);

    demo_print("C style string ", s); // c-style string 和C++ string

    vector <string> languages {"C++", "Python", "Java"};
    demo_print(languages);

    
    return 0;
}

void demo_print(int num){
    cout << "整数：" << num << endl;
}
void demo_print(double num){
    cout << "浮点数：" << num << endl;
}

void demo_print(string s){
    cout << "字符串：" << s << endl;
}
void demo_print(string s1, string s2){
    cout << s1 << s2 << endl;
}
void demo_print(vector <string> v){
    cout << "字符串向量：" << endl;
    for (auto s: v){
        cout << s << " ";
    }
    cout << endl;
}
1.5 函数传参——传递数组（array）

在这里插入图片描述

• 数组元素并没有复制！
• 数组变量名称表示第⼀个元素在内存中的地址——这个地址才被复制了
• 函数内部⽆法知道数组⼤⼩（数组⼤⼩需要额外传参）

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

• 声明参数 numbers是常量（只读 read-only）

在这里插入图片描述

代码：

#include <iostream>
using namespace std;

// 打印数组
void print_arr(const int arr[], size_t size);
// 变更数组内容
void change_arr(int arr[], size_t size);

int main()
{
    // 传递数组给函数
    int student_scores [] {100,99,98,97};

    cout << "数组的地址是：" << student_scores << endl;

    print_arr(student_scores, 4); // 100 99 98 97
    change_arr(student_scores, 4); // 变更数组内容
    print_arr(student_scores, 4); // 60 60 60 60

    // print_arr(student_scores, 4); // 1000 60 60 60
}

void print_arr(const int arr[], size_t size){
    cout << "print_arr函数内数组的地址是：" << arr << endl;

    for (size_t i {0}; i < size; i++){
        cout << arr[i] << " ";
    }
    // arr[0] = 1000; // 不能修改数组内容
    cout << endl;
}

void change_arr(int arr[], size_t size){
    cout << "change_arr函数内数组的地址是：" << arr << endl;

    for (size_t i {0}; i < size; i++){
        arr[i] = 60;
    }
}
1.6 函数的传参——引⽤传递（pass by reference）

• 有时希望在函数体内部改变实参的值
• 需要实参的地址
• 类似数组⽅式改变原始实参，别的类型能否⽀持？
• 可以使⽤引⽤传参给函数，形参会变成实参的⼀个别名（alias）

例子：
在这里插入图片描述

在这里插入图片描述

代码：

#include <iostream>
#include <vector>
#include <string>

using namespace std;

void pass_by_ref_1(int &num)
{
    num = 100;
}
void pass_by_ref_2(string &s)
{
    s = "Changed";
}
void pass_by_ref_3(vector<string> &v)
{
    v.clear(); // 清空vector
}
void print_vector(const vector<string> &v)
{
    for (auto s : v){
        cout << s << " ";
    }
    cout << endl;
}
int main()
{
    cout << "====================" << endl;
    int my_num {19};
    cout << "修改前的值：" << my_num << endl; // 19
    pass_by_ref_1(my_num);
    cout << "修改后的值：" << my_num << endl; // 100

    cout << "====================" << endl;
    string my_str {"Hello"};
    cout << "修改前的值：" << my_str << endl; // Hello
    pass_by_ref_2(my_str);
    cout << "修改后的值：" << my_str << endl; // Changed

    cout << "====================" << endl;
    vector<string> my_vec {"apple", "banana", "orange"};
    cout << "修改前的值：";
    print_vector(my_vec); // apple banana orange
    pass_by_ref_3(my_vec);
    cout << "修改后的值：";
    print_vector(my_vec); // 空

    return 0;
}
1.7 函数的传参——vector Demo

通过值传递，内存会重新开一处地址存储vector的内容，如果vector较大，将会耗时耗资源，

在这里插入图片描述

而通过vector的地址传递，内存就不会再开一处地址存储，

在这里插入图片描述

在这里插入图片描述

示例代码：

#include <iostream>
#include <vector>
#include <string>

using namespace std;

void pass_by_ref_1(int &num)
{
    num = 100;
}
void pass_by_ref_2(string &s)
{
    s = "Changed";
}
void pass_by_ref_3(vector<string> &v)
{
    v.clear(); // 清空vector
}
void print_vector(const vector<string> &v)
{
    for (auto s : v){
        cout << s << " ";
    }
    cout << endl;
}
int main()
{
    cout << "====================" << endl;
    int my_num {19};
    cout << "修改前的值：" << my_num << endl; // 19
    pass_by_ref_1(my_num);
    cout << "修改后的值：" << my_num << endl; // 100

    cout << "====================" << endl;
    string my_str {"Hello"};
    cout << "修改前的值：" << my_str << endl; // Hello
    pass_by_ref_2(my_str);
    cout << "修改后的值：" << my_str << endl; // Changed

    cout << "====================" << endl;
    vector<string> my_vec {"apple", "banana", "orange"};
    cout << "修改前的值：";
    print_vector(my_vec); // apple banana orange
    pass_by_ref_3(my_vec);
    cout << "修改后的值：";
    print_vector(my_vec); // 空

    return 0;
}
1.8 函数调⽤机制

1、 使⽤函数调⽤栈（function call stack）
----->• 类⽐⼀摞书
----->• LIFO（后⼊先出，last in first out）
----->• ⼊栈（push）：在栈顶添加记录
----->• 出栈（pop）：从栈顶移除记录
2、 栈帧（stack frame）或活动记录（activation record）
----->• 每次函数被调⽤，⼊栈⼀条新的活动记录；
----->• 函数结束，活动记录出栈移除，返回⾄调⽤函数的位置
----->• 局部变量（local variables）和函数会在栈上分配空间
3、 栈的⼤⼩有限，超出会栈溢出（stack overflow）

内存模型：
在这里插入图片描述

代码1：

#include <iostream>
using namespace std;

void func_2(int &x, int y,int z)
{
    x += y + z;
}
int func_1(int a, int b)
{
    int result {};
    result = a + b;
    func_2(result, a, b);
    return result;
}
    

int main()
{
    int x {20};
    int y {30};
    int z {};

    z = func_1(x, y);

    cout << "z = " << z << endl;  // 100

    
    return 0;
}

代码2：

#include <iostream>
using namespace std;

unsigned long long factorial(unsigned long long n)
{
    if (n == 0)
        return 1; // 最终返回的是1
    return n * factorial(n - 1);  // 递归调用
}

int main()
{
    cout << factorial(3) << endl; // 6
    cout << factorial(8) << endl; // 40320
    cout << factorial(12) << endl; // 479001600
    cout << factorial(20) << endl; // 2432902008176640000
}

2、C++ 指针（pointer）

2.1 指针（pointer）介绍

1、 指针是变量
------>• 变量的值是⼀个地址
2、指针的值可以存储哪些地址？
------>• 另⼀个变量
------>• 函数
3、⽐如：int a = 20，可以声明⼀个指针指向它

这里是引用

A、声明指针
在这里插入图片描述

B、初始化指针
在这里插入图片描述

C、地址操作符 &
在这里插入图片描述

在这里插入图片描述

指针的大小都是一样的，但指针指向的变量大小可能就不一样；需要区分指针和指针指向的变量的关系

在这里插入图片描述

• 编译器需要检查指针变量存储地址的类型

在这里插入图片描述

D、重要概念

• & 地址操作符
• 指针也是⼀个变量（variable），所以它的值可以改变
• 指针可以为null
• 指针可以不初始化

在这里插入图片描述

代码：

#include <iostream>
#include <vector>
#include <string>

using namespace std;

int main()
{
    cout << "=====================" << endl;
    int my_num {10};
    cout << "my_num变量的值是: " << my_num << endl;
    cout << "my_num变量的sizeof是: " << sizeof(my_num) << endl;
    cout << "my_num变量的地址是: " << &my_num << endl; 

    cout << "=====================" << endl;
    int *num_ptr;
    cout << "num_ptr变量的值是: " << num_ptr << endl;  // 随机的地址
    cout << "num_ptr变量的sizeof是: " << sizeof(num_ptr) << endl;
    cout << "num_ptr变量的地址是: " << &num_ptr << endl;  // 指向num_ptr的地址

    num_ptr = nullptr;  // 0
    cout << "num_ptr变量的值是: " << num_ptr << endl; // 0



    cout << "=====================" << endl;
    int *p1 {nullptr};
    double *p2 {nullptr};
    long long *p3 {nullptr};
    string *p4 {nullptr};
    vector<string> *p5 {nullptr};

    cout << "p1的sizeof是: " << sizeof(p1) << endl;  // 8  
    cout << "p2的sizeof是: " << sizeof(p2) << endl;  // 8
    cout << "p3的sizeof是: " << sizeof(p3) << endl;  // 8 
    cout << "p4的sizeof是: " << sizeof(p4) << endl;  // 8
    cout << "p5的sizeof是: " << sizeof(p5) << endl;  // 8


    cout << "=====================" << endl;
    int student_score {100};
    double high_temp {41.5};

    int *score_ptr {nullptr};
    score_ptr = &student_score;
    
    cout << "student_score的值是: " << student_score << endl;
    cout << "student_score的地址是: " << &student_score << endl;
    cout << "score_ptr的值是: " << score_ptr << endl;

    // score_ptr = &high_temp; // 会报错，因为score_ptr是int类型的指针，不能指向double类型的变量
    
    return 0;
}
2.2 指针的解引⽤（dereference）

• 获取指针指向的数据——解引⽤

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
代码：

#include <iostream>
#include <vector>

using namespace std;

int main()
{

    cout << "========================" << endl;
    int student_score {100};
    int *score_ptr {&student_score};

    cout << "student_score的值是: " << student_score << endl;  // 100
    cout << "通过指针score_ptr访问student_score的值是: " << *score_ptr << endl;  // 100

    // 重新赋值
    *score_ptr = 150;
    cout << "Updated,student_score的值是: " << student_score << endl;  // 150
    cout << "Updated,通过指针score_ptr访问student_score的值是: " << *score_ptr << endl;  // 150


    cout << "========================" << endl;
    double high_temp {41.5};
    double low_temp {37.5};

    double *temp_ptr {&high_temp};
    cout << "通过指针temp_ptr访问high_temp的值是: " << *temp_ptr << endl;

    temp_ptr = &low_temp;
    cout << "通过指针temp_ptr访问low_temp的值是: " << *temp_ptr << endl;


    cout << "========================" << endl;
    string str {"Hello"};
    string *str_ptr {&str};
    cout << "通过指针str_ptr访问str的值是: " << *str_ptr << endl;
    str = "World";
    cout << "Updated,通过指针str_ptr访问str的值是: " << *str_ptr << endl;

    cout << "========================" << endl;
    vector <string> my_str_vec {"Hello", "World", "computer", "vision"};
    vector <string> *vector_ptr {&my_str_vec};

    cout << "my_str_vec的第一个元素是: " << my_str_vec.at(0) << endl;
    cout << "通过指针vector_ptr访问my_str_vec的第一个元素是: " << (*vector_ptr).at(0) << endl;

    cout << "遍历所有元素：";
    for (auto str: *vector_ptr)
    {
        cout << str << " ";
    }
    cout << endl;

    return 0;
}
2.3 动态内存分配（dynamic memory allocation）

• 在堆（heap）上程序员⾃⼰分配内存空间；
• 回忆下C++ 数组（array）
------>• 使⽤数组需要知道数组⼤⼩，并且数组⼤⼩是固定的；
------>• Vector容器⼤⼩可以动态调整
• 使⽤指针获取堆上刚分配的内存空间

• 使⽤new 关键字 分配内存空间

在这里插入图片描述

• 使⽤delete 关键字 释放内存空间

在这里插入图片描述

• 使⽤new[ ] 为数组分配内存空间
• 使⽤delete[ ] 释放内存

在这里插入图片描述

代码：

#include <iostream>
#include <vector>

using namespace std;

int main()
{
    int *int_ptr {nullptr};

    cout << "分配前的int_ptr的值是: " << int_ptr << endl; // 0
    int_ptr = new int; // 在heap堆上分配一个int类型的内存空间，返回该内存空间的地址
    cout << "分配后的int_ptr的值是: " << int_ptr << endl; // 0x7ffeeb5c9f7c
    cout << *int_ptr << endl; // 0

    *int_ptr = 100; // 通过指针修改内存空间的值
    cout << *int_ptr << endl; // 100

    delete int_ptr; // 释放内存空间
   

    size_t size {0};
    double *temp_ptr {nullptr};
    cout << "多少个温度值？";
    cin >> size;
    temp_ptr = new double[size]; // 在heap堆上分配size个double类型的内存空间，返回该内存空间的地址
    cout << "地址是: " << temp_ptr << endl;
    delete [] temp_ptr; // 释放内存空间

    return 0;
}
2.4 指针和数组的关系

• 数组变量名称的值是数组第⼀个元素的地址；
• 指针变量的的值是⼀个地址；
• 如果指针指向的类型和数组元素的类型⼀致，那么指针和数组名称⼏乎是等价的

**缺图片**

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

代码：

#include <iostream>
using namespace std;

int main()
{
    int student_scores [] {100, 98, 90};
    cout << "student_scores的值是: " << student_scores << endl; 

    int *score_ptr {student_scores}; // score_ptr指向student_scores数组的第一个元素
    cout << "score_ptr的值是: " << score_ptr << endl; 

    cout << "====== 数组名称，下标方式访问元素 ====== " << endl;
    cout << student_scores[0] << endl; // 100
    cout << student_scores[1] << endl; // 98
    cout << student_scores[2] << endl; // 90

    cout << "====== 指针名称，下标方式访问元素 ====== " << endl;
    cout << score_ptr[0] << endl; // 100
    cout << score_ptr[1] << endl; // 98
    cout << score_ptr[2] << endl; // 90

    cout << "====== 指针名称，指针运算符方式访问元素 ====== " << endl;
    cout << *score_ptr << endl; // 100
    cout << *(score_ptr + 1) << endl; // 98
    cout << *(score_ptr + 2) << endl; // 90

    cout << "====== 数组名称，指针运算符方式访问元素 ====== " << endl;
    cout << *student_scores << endl; // 100
    cout << *(student_scores + 1) << endl; // 98
    cout << *(student_scores + 2) << endl; // 90

    cout << "====== ++运算符 ====== " << endl;
    // 但需要注意++会改变指针的值，下次访问的就不是原来的位置了
    cout << *score_ptr++ << endl; // 100
    cout << *score_ptr++ << endl; // 98
    cout << *score_ptr << endl; // 90

    return 0;
}
2.5 const和指针

• 指针可以操作：地址及被指向的对象，可以分为以下3种情况：
------>• 被指向的对象是常量（pointers to constants）
------>• 指针本身是常量（constant pointers）
------>• 指针本身和被指向的对象都是常量（constant pointers to constants）

A、被指向的对象是常量

• 被指向的对象是常量，不可以通过指针改动
• 指针本身可以改变

**缺**

B、指针本身是常量

• 被指向的对象可以通过指针改动
• 指针本身不可以改变

**缺**

C、指针本身和被指向的对象都是常量

• 被指向的对象不可以改动
• 指针本身不可以改变

**缺**

代码：

#include <iostream>
#include <string>
#include <vector>

using namespace std;

void display(const vector<string> *const v)
{
    // (*v).at(0) = "kiwi"; // 修改vector中的第一个元素
    for (auto str: *v)
        cout << str << " ";
    cout << endl;
    // v = nullptr; // 修改指针的值
}
void display(int *array, int sentinel)
{
    while (*array != sentinel)
        cout << *array++ << endl;
    cout << endl;
   
}

int main()
{
    // 定义string vector，并打印
    vector<string> my_str {"apple", "orange", "banana"};
    display(&my_str);

    cout << "====================" << endl;
    int student_scores [] {100, 98, 90, 86, 84, -1};
    display(student_scores, -1);

    return 0;
}
2.6 函数指针传参

• 使⽤指针、解引⽤实现函数引⽤传参
• 函数的形参是指针
• 实参可以是指针或⼀个变量的地址

在这里插入图片描述

在这里插入图片描述

代码1：

#include <iostream>
using namespace std;

// 定义函数
void double_data(int *int_ptr);

void double_data(int *int_ptr)
{
    *int_ptr *= 2;
}

int main()
{
    // 函数调用
    int value {20};

    cout << "value的值是: " << value << endl; // 20
    double_data(&value); // 传递value的地址
    cout << "value的值是: " << value << endl; // 40

    int *int_ptr {nullptr}; // 声明指针
    int_ptr = &value; // 将value的地址赋值给指针
    double_data(int_ptr); // 传递指针
    cout << "value的值是: " << value << endl; // 80

    return 0;
}

代码2：

#include <iostream>
using namespace std;

// 定义函数
void swap_value(int *a, int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main()
{
    // 函数调用
    int x {100}, y {200};
    cout << "交换前，x的值是: " << x << endl; // 100
    cout << "交换前，y的值是: " << y << endl; // 200

    swap_value(&x, &y); // 将变量x和y的地址传递给函数
    cout << "====================" << endl;
    cout << "交换后，x的值是: " << x << endl; // 200
    cout << "交换后，y的值是: " << y << endl; // 100

    return 0;
}
2.7 函数返回指针

• 函数可以返回指针：
------->• Type *function( );
• 返回哪些指针：
------->• 函数内部动态分配的内存空间
------->• 传⼊的数据
• 不能返回函数内的局部变量

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

不能返回函数内的局部变量，如下面的示例，如果返回的是函数内的局部变量，随着函数运行结束，同在栈上的 size 变量也会被释放，size 的地址有可能被其他新的变量所占用，如果使用解引用指向其他变量就有可能造成程序的 bug，

在这里插入图片描述

代码：

#include <iostream>
using namespace std;

// 返回动态分配的内存
int *create_array(size_t size, int initial_value = 0)
{
    int *new_storage{nullptr};

    new_storage = new int[size]; // 分配内存

    for (size_t i{0}; i < size; i++)
    {
        // 初始化值
        *(new_storage + i) = initial_value;
        // new_storage[i] = initial_value; // 等价于上一行
    }
    return new_storage;
}

// 显示数组
void display(int *array, size_t size)
{
    for (size_t i{0}; i < size; i++)
    {
        cout << *array++ << " ";
    }
    cout << endl;
}

int main()
{
    size_t size{};
    int value{};
    int *new_arr{nullptr};

    cout << "请输入数组的大小: ";
    cin >> size;
    cout << "请输入数组的初始值: ";
    cin >> value;

    new_arr = create_array(size, value); // 动态分配内存

    display(new_arr, size); // 显示数组

    delete[] new_arr; // 释放内存

    return 0;
}
2.8 指针、引⽤对⽐——回顾⼀下引⽤（reference）

引用是变量的替身或别名
引用本身是一个常量的指针

在这里插入图片描述

指针、引⽤的对⽐， 其中我对引用传值中不支持指向其他变量有疑惑，

在这里插入图片描述

代码：

#include <iostream>
#include <string>
#include <vector>

using namespace std;

int main()
{
    int my_num {10};
    int &my_ref {my_num}; // 引用

    cout << "my_num: " << my_num << endl;  // 10
    cout << "my_ref: " << my_ref << endl;  //10
    my_ref = 100; // 修改引用，my_num也会被修改
    cout << "my_num: " << my_num << endl;  //100
    cout << "my_ref: " << my_ref << endl;  //100


    vector<string> my_str {"Hello", "World", "!"};
    cout << "=====================" << endl;
    for (auto str:my_str) // 这里的str是一个拷贝
        str = "Hello";

    for (auto str:my_str)
        cout << str << endl; // 输出的是原来的字符串
    
    cout << "=====================" << endl;
    for (auto &str:my_str) // 这里的str是一个引用
        str = "Hello";

    for (auto str:my_str)
        cout << str << endl; // 输出的是修改后的字符串
    
    cout << "=====================" << endl;
    for (auto const &str:my_str) // 这里的str是一个常量引用
    {
        // str = "computer"; // 这里会报错，因为str是一个常量引用
        cout << str << endl;
    }
        
    return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1110736.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

drawio都能做那些事情和模板示例

drawio都能做那些事情和模板示例

drawio都能做那些事情和模板示例 你可以使用drawio&#xff0c;并使用drawio提供的扩展模板库和大量的形状库&#xff0c;针对很多不同的工业领域创建不同类型的图表。 针对如下的内容中的所有的图&#xff0c;均可以下载源文件并导入到drawio中再次编辑&#xff08;供学习者…
阅读更多...
如何远程通过内网穿透实现微信公众号在本地的完整调试

如何远程通过内网穿透实现微信公众号在本地的完整调试

文章目录 前言1. 配置本地服务器2. 内网穿透2.1 下载安装cpolar内网穿透2.2 创建隧道 3. 测试公网访问4. 固定域名4.1 保留一个二级子域名4.2 配置二级子域名 5. 使用固定二级子域名进行微信开发 前言 在微信公众号开发中&#xff0c;微信要求开发者需要拥有自己的服务器资源来…
阅读更多...
什么是兼容性测试? 重要性是什么?

什么是兼容性测试? 重要性是什么?

在数字化时代&#xff0c;用户使用各种不同类型的设备和操作系统来访问应用程序和网站。为了确保用户体验的一致性和应用程序的可用性&#xff0c;兼容性测试变得至关重要。本文将深入探讨兼容性测试的概念及重要性。 一、什么是兼容性测试? 兼容性测试是一种软件测试方法&…
阅读更多...
混入组件 (mixin)

混入组件 (mixin)

1 什么是混入以及作用 *混入 (mixin) 提供了一种非常灵活的方式&#xff0c;来分发 Vue 组件中的可复用功能。一个混入对象可以包含任意组件选项。当组件使用混入对象时&#xff0c;所有混入对象的选项将被“混合”进入该组件本身的选项。作用&#xff1a;主要作用是继承和封装…
阅读更多...
【python】什么是网络爬虫？

【python】什么是网络爬虫？

什么是网络爬虫&#xff1f; 网络爬虫是一种自动化程序&#xff0c;用于从互联网上抓取信息。这些信息可以是文本、图像、视频、数据表格等各种形式的数据。爬虫程序通过模拟浏览器的行为&#xff0c;自动访问网页、抓取内容&#xff0c;并将其保存或处理。这对于数据挖掘、搜索…
阅读更多...
elasticsearch的docker安装与使用

elasticsearch的docker安装与使用

安装 docker network create elasticdocker pull docker.elastic.co/elasticsearch/elasticsearch:8.10.4# 增加虚拟内存&#xff0c; 此处适用于linux vim /etc/sysctl.conf # 添加 vm.max_map_count262144 # 重新启动 sysctl vm.max_map_countdocker run --name es01 --net …
阅读更多...
element中form表单验证

element中form表单验证

type&#xff1a;限定类型 pattern&#xff1a;添加正则表达式规则 transform&#xff1a;规则验证之前执行的函数 参考Element Ui使用技巧——Form表单的校验规则rules详细说明&#xff1b;element的 form 表单rules详细用法_橙cplvfx-技术踩坑记的技术博客_51CTO博客
阅读更多...
【java】【重构二】分模块开发版本锁定以及耦合（打包）实战

【java】【重构二】分模块开发版本锁定以及耦合（打包）实战

目录 一、创建dependencyManagement标签 二、 将需要版本控制的依赖版本进行标签设置 三、将需要版本控制的依赖从各子模块迁移到此处 四、将父模块的依赖版本控制 五、删除子模块的全部版本 1、bocai-web-management模块 2、bocai-utils模块 六、打包 1、确定代码都…
阅读更多...
三相电表倍率是什么？

三相电表倍率是什么？

三相电表的倍率是指电能表所匹配的互感器的倍率&#xff0c;也称为变比变流(压)比、电流(压)比&#xff0c;就是缩小的比例。 实际的用电量等于电能表的表值乘以倍率。 三相电能表是用来测量三相交流电路中电源输出(或负载消耗)的电能的电度表。 按用途可分为工业与民用表、电子…
阅读更多...
QCA中质蕴项选择问题

QCA中质蕴项选择问题

一、关于质蕴项的基础知识 &#xff08;一&#xff09;什么是质蕴项&#xff1f; &#xff08;1&#xff09;质蕴项定义 逻辑余项是指缺少经验实例的构型&#xff0c;可以被纳入布尔最小化。——QCA设计原理与应用&#xff1a;超越定性与定记研究的新方法 &#xff08;2&…
阅读更多...
黄金眼PAAS化数据服务DIFF测试工具的建设实践 | 京东云技术团队

黄金眼PAAS化数据服务DIFF测试工具的建设实践 | 京东云技术团队

一、背景介绍 黄金眼PAAS化数据服务是一系列实现相同指标服务协议的数据服务&#xff0c;各个服务间按照所生产指标的主题作划分&#xff0c;比如交易实时服务提供实时交易指标的查询&#xff0c;财务离线服务提供离线财务指标的查询。黄金眼PAAS化数据服务支撑了黄金眼APP、黄…
阅读更多...
出租房水电表管理系统：实现节能减排与经济效益双赢

出租房水电表管理系统：实现节能减排与经济效益双赢

随着我国城市化进程的加速&#xff0c;出租房市场日益繁荣&#xff0c;房东与租户之间的水电费管理问题也日益凸显。传统的出租房水电费管理方式存在诸多不便&#xff0c;如收费不透明、数据不准确、浪费严重等问题。出租房水电表管理系统应运而生&#xff0c;那么今天小编就来…
阅读更多...
AI四维彩超预测宝宝长相图片生成流量主小程序开发

AI四维彩超预测宝宝长相图片生成流量主小程序开发

AI四维彩超预测宝宝长相图片生成流量主小程序开发 以下是AI四维彩超预测宝宝长相图片生成流量主小程序的功能列表&#xff1a; 用户注册和登录功能&#xff1a;允许用户注册新账户或使用现有账户登录。用户上传宝宝四维彩超照片&#xff1a;用户可以上传宝宝的四维彩超照片&am…
阅读更多...
2010 数一 text(1)

2010 数一 text(1)

阅读更多...
标准模板库--STL

标准模板库--STL

这里写目录标题 STL初始STL诞生STL基本概念STL六大组件STL中的容器、算法、迭代器容器算法迭代器初识vector存放内置数据类型vector存放自定义数据类型vector中嵌套vector 二级目录二级目录二级目录二级目录二级目录二级目录二级目录二级目录 STL初始 STL诞生 STL基本概念 STL…
阅读更多...
工业RFID厂家与您分享工业生产制造的应用案例

工业RFID厂家与您分享工业生产制造的应用案例

随着科技的不断进步&#xff0c;RFID技术在工业生产制造领域的应用越来越广泛。AGV/RGV小车运输、立体仓库、生产线、物料跟踪与管理等各行业工业自动化的使用上都有着RFID的身影。为工业生产制造智能化自动化提供了助力。下面&#xff0c;为大家分享RFID技术在工业生产制造上的…
阅读更多...
基于JAVA+SpringBoot的学生成长管理评价系统

基于JAVA+SpringBoot的学生成长管理评价系统

✌全网粉丝20W,csdn特邀作者、博客专家、CSDN新星计划导师、java领域优质创作者,博客之星、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域和毕业项目实战✌ &#x1f345;文末获取项目下载方式&#x1f345; 一、项目背景介绍&#xff1a; 学生成长管理评价系统…
阅读更多...
JAVA基础（JAVA SE）学习笔记（五）数组

JAVA基础（JAVA SE）学习笔记（五）数组

前言 1. 学习视频&#xff1a; 尚硅谷Java零基础全套视频教程(宋红康2023版&#xff0c;java入门自学必备)_哔哩哔哩_bilibili 2023最新Java学习路线 - 哔哩哔哩 正文 第一阶段&#xff1a; JAVA基础&#xff08;JAVA SE&#xff09;学习笔记&#xff08;一&#xff09;…
阅读更多...
SpringMVC之全局异常拦截器

SpringMVC之全局异常拦截器

在SpringMVC自动装配核心类之WebMvcAutoConfiguration内部实例化EnableWebMvcConfiguration过程中会触发其父类WebMvcConfigurationSupport内部初始化HandlerExceptionResolver。 1.WebMvcConfigurationSupport public class WebMvcConfigurationSupport implements Applicat…
阅读更多...
51单片机的时钟系统

51单片机的时钟系统

1.简介 51内置的时钟系统可以用来计时&#xff0c;与主程序分割开来&#xff0c;在计时过程中不会终端主程序&#xff0c;还可以通过开启时钟中断来执行相应的操作。 2.单片机工作方式 单片机内部有两个十六位的定时器T0和T1。每个定时器有两种工作方式选择&#xff0c;分别…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023