10.const修饰函数参数

编程语言 > CPP > CPP核心 > CPP核心语法知识 编程语言 CPP CPP核心 CPP核心语法知识 面向对象 封装
发布时间 :
字数:2.2k 阅读 : 评论:
  1. 10.面向对象-封装-const修饰函数参数
    1. 10.1 知识点
      1. const 修饰函数参数：基本类型
      2. const 修饰函数参数：指针
        1. 1. 指向能改，值不能改（指向常量的指针）
        2. 2. 指向不能改，值能改（指针常量）
        3. 3. 指向不能改，值也不能改（指向常量的指针常量）
      3. const 修饰函数参数：引用
        1. 对比：不加 const 修饰引用参数
    2. 10.2 知识点代码
      1. Lesson10_面向对象_封装_const修饰函数参数.cpp
    3. 10.3 练习题
      1. 为什么要用 const 修饰函数参数？
    4. 10.4 练习题代码
      1. Lesson10_练习题.cpp

10.面向对象-封装-const修饰函数参数

10.1 知识点

const 修饰函数参数：基本类型

  • 规则：返回值 函数名(const int 参数名)

  • 作用：

    • 不允许传入的参数在函数内部被修改
    • 但意义不大 —— 因为即便在内部修改也不会影响外部
void test(const int i)
{
    // i = 1111; // 报错
    cout << i << endl;
    int j = i + 10;
}

int i = 10;
test(i); // 输出 10

const 修饰函数参数：指针

1. 指向能改，值不能改（指向常量的指针）

  • 规则：返回值 函数名(const 类型* 参数名)

  • 作用：

    • 指针可以修改指向
    • 但不能修改指针所指向的数据
    • 主要用于防止修改指针指向的值
void test2(const int* iPtr)
{
    // *iPtr = 10; // 报错，不能修改值
    iPtr = nullptr; // 可以修改指向
}

2. 指向不能改，值能改（指针常量）

  • 规则：返回值 函数名(类型* const 参数名)

  • 作用：

    • 指针的指向不能改变
    • 但可以修改指针所指向的数据
    • 主要用于防止指针被重新赋值
void test3(int* const i)
{
    *i = 10;       // 可以修改值
    // i = nullptr; // 报错，不能修改指向
}

3. 指向不能改，值也不能改（指向常量的指针常量）

  • 规则：返回值 函数名(const 类型* const 参数名)

  • 作用：

    • 指针指向不能改变
    • 指针指向的数据也不能被修改
void test4(const int* const i)
{
    // *i = 10;      // 报错，不能改值
    // i = nullptr;  // 报错，不能改指向
}

✅ 一般推荐使用第一种方式（const int*），可以提高代码安全性。

const 修饰函数参数：引用

  • 规则：返回值 函数名(const 类型& 参数名)

  • 作用：

    • 常量对象和非常量对象都可以传入
    • 不能修改对象本身
    • 由于是引用传递，还可以避免拷贝开销
void test5(const int& i)
{
    // i = 10; // 报错
}

对比：不加 const 修饰引用参数

  • 不能传入常量对象
  • 因为参数没有 const 修饰，而常量对象不能被修改
void test6(int& i)
{
    i = 10;
}

int i = 10;
const int i2 = 10;
test5(i);   // 可以
test5(i2);  // 可以

test6(i);   // 可以
// test6(i2); // 报错，因为参数不是 const 引用

10.2 知识点代码

Lesson10_面向对象_封装_const修饰函数参数.cpp

#include <iostream>
using namespace std;

//  规则：返回值 函数名(const int等基础类型 参数名)
//  作用：不允许传入的参数在内部修改（但是意义不大，因为就算内部修改也不会影响外部）
void test(const int i)
{
    //i = 1111;//报错
    cout << i << endl;
    int j = i + 10;
}

//  1.指向能改，值不能改（相当于指向常量的指针）
//  规则：返回值 函数名(const 类型* 参数名)
//  作用：该指针可以修改指向，但是指向的值不能修改，主要用于放置修改指针指向内容的值
void test2(const int* iPtr)
{
    //指向能改，值不能改（相当于指向常量的指针）
    //*iPtr = 10;//报错
    iPtr = nullptr;
}

//  2.指向不能改，值能改（相当于指针常量）
//  规则：返回值 函数名( 类型* const 参数名)
//  作用：该指针可以修改指向，但是指向的值不能修改，主要用于放置修改指针指向内容的值
void test3(int* const i)
{
    //指向不能改，值能改（相当于指针常量）
    *i = 10;
    //i = nullptr;、//报错
}

//  3.指向不能改，值也不能能改（相当于指向常量的指针常量）
//  规则：返回值 函数名( const 类型* const 参数名)
//  作用：该指针可以修改指向，但是指向的值不能修改，主要用于放置修改指针指向内容的值
void test4(const int* const i)
{
    //指向不能改，值也不能能改（相当于指向常量的指针常量）
    //*i = 10;
    //i = nullptr;
}

//  一般推荐使用第一种方式，可以提高代码安全性


//  规则：返回值 函数名( const 类型& 参数名)
//  作用：常量对象和非常量对象都可以传入，但不能修改对象本身，由于是引用，还可以避免拷贝开销
void test5(const int& i)
{
    //i = 10;
}

//不加const 不能传常量对象引用进来
//因为参数没有const修饰 传入的有是const const是不能被修改的
void test6(int& i)
{
    i = 10;
}

int main()
{
    #pragma region 知识点一 const修饰函数参数：基本类型

    //  规则：返回值 函数名(const int等基础类型 参数名)
    //  作用：不允许传入的参数在内部修改（但是意义不大，因为就算内部修改也不会影响外部）
    int i = 10;
    test(i);//10

    #pragma endregion

    #pragma region 知识点二 const修饰函数参数：指针
    //  1.指向能改，值不能改（相当于指向常量的指针）
    //  规则：返回值 函数名(const 类型* 参数名)
    //  作用：该指针可以修改指向，但是指向的值不能修改，主要用于放置修改指针指向内容的值
    // 
    //  2.指向不能改，值能改（相当于指针常量）
    //  规则：返回值 函数名( 类型* const 参数名)
    //  作用：该指针可以修改指向，但是指向的值不能修改，主要用于放置修改指针指向内容的值
    // 
    //  3.指向不能改，值也不能能改（相当于指向常量的指针常量）
    //  规则：返回值 函数名( const 类型* const 参数名)
    //  作用：该指针可以修改指向，但是指向的值不能修改，主要用于放置修改指针指向内容的值
    // 
    //  一般推荐使用第一种方式，可以提高代码安全性
    #pragma endregion

    #pragma region 知识点三 const修饰函数参数：引用

    //  规则：返回值 函数名( const 类型& 参数名)
    //  作用：常量对象和非常量对象都可以传入，但不能修改对象本身，由于是引用，还可以避免拷贝开销

    const int i2 = 10;
    test5(i);
    test5(i2);

    test6(i);
    //test6(i2);//报错 因为参数没有const修饰 传入的有是const

    #pragma endregion
}

10.3 练习题

为什么要用 const 修饰函数参数？

  1. 防止修改参数

    • 核心作用：避免变量在函数内部被意外修改。
    • 适用场景：当参数为引用或指针时，通过 const 修饰可禁止函数内对参数的修改。

  2. 提高代码可读性

    • 协同开发优势：其他开发者看到函数参数带有 const 时，可明确该参数在函数内部不会被修改，提升代码直观性。

  3. 支持向函数传递 const 对象

    • 限制条件：若函数参数未用 const 修饰，无法向函数传递 const 对象的引用或指针。

  4. 提高代码安全性

    • 防篡改机制：通过禁止修改参数，避免因误操作导致的数据异常，增强程序稳定性。

  5. 允许传递临时对象

    • 临时对象特性：C++ 中临时对象默认为 const（常量），不可修改。
    • 解决方案：参数添加 const 修饰后，可接收临时对象的引用，扩展函数适用性。
void test(const int& i)
{
    cout << i << endl;
}

int i = 10;
test(i);

// 如果函数的引用参数没有加 const 修饰
// 这样直接传递 10（临时对象）会报错
// 加了 const 修饰 就不会报错
test(10);

10.4 练习题代码

Lesson10_练习题.cpp

#include <iostream>
using namespace std;
void test(const int& i)
{
    cout << i << endl;
}

int main()
{
    #pragma region 练习题
    //为什么要用const修饰函数参数？请说出你的理解

    //1.防止修改参数
    //  const关键字的主要作用就是避免变量被修改
    //	如果参数是一个引用或者指针，我们可以通过添加const的形式，避免在函数内部修改内容

    //2.提高代码可读性
    //	当我们协同开发时，使用别人写的代码，看到函数参数有const，就可以明确知道这个参数内部不会被修改
    //	使得代码更加直观

    //3.支持向函数中传递const对象
    //	如果是const对象，如果函数参数没有const修饰，对于引用和指针参数是无法传入const对象的

    //4.提高安全性
    //	防止修改参数的特点，就可以提到安全性，因为可以避免在函数中修改不想被修改的参数

    //5.加上const允许我们往函数中传递临时对象
    //	在C++中临时对象是const（常量）的，不允许被修改，加上const我们便可以传递临时对象引用
    int i = 10;
    test(i);

    //如果函数的引用参数没有加const修饰 这样直接传的这个10临时对象是个常量来的 会报错
    //加了const修饰 就不会报错
    test(10);

    #pragma endregion

}
转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 785293209@qq.com

赏

©2016-2024 Tao

Built with Hexo and 3-hexo theme

×

喜欢就点赞,疼爱就打赏