2.函数基础

编程语言 > CPP > CPP基础 > CPP基础语法知识 编程语言 CPP CPP基础 函数 CPP基础语法知识
发布时间 :
字数:4k 阅读 : 评论:
  1. 2.函数-函数基础
    1. 2.1 知识点
      1. 基本概念
      2. 函数在哪里声明
      3. 基本语法
      4. 实际运用
        1. 函数声明
        2. 函数定义
        3. 函数使用
      5. 关于 return
        1. 函数声明
        2. 函数定义
        3. 函数使用
      6. 总结
    2. 2.2 知识点代码
      1. Lesson02_函数_函数基础.cpp
    3. 2.3 练习题
      1. 写一个函数，比较两个数字的大小，返回最大值
        1. 函数声明
        2. 函数定义
        3. 函数使用
      2. 写一个函数，用于计算一个圆的面积和周长，并打印
        1. 函数声明
        2. 函数定义
        3. 函数使用
      3. 写一个函数，判断你传入的参数是不是质数
        1. 函数声明
        2. 函数定义
        3. 函数使用
      4. 写一个函数，判断你输入的年份是否是闰年
        1. 闰年判断条件：
        2. 函数声明
        3. 函数定义
        4. 函数使用
    4. 2.4 练习题代码
      1. Lesson02_练习题.cpp

2.函数-函数基础

2.1 知识点

基本概念

函数（方法）本质是一块具有名称的代码块。可以使用函数（方法）的名称来执行该代码块。函数（方法）是封装代码进行重复使用的一种机制。

函数（方法）的主要作用：

  • 封装代码
  • 提升代码复用率（少写点代码）
  • 抽象行为

函数在哪里声明

  • 标准的做法是：

    • 函数的声明一般在头文件（.h）中
    • 函数的定义一般在源文件（.cpp）中

  • 目前，我们还没有学习头文件和源文件的知识，因此我们直接将函数声明和定义放在源文件（.cpp）中。

  • 注意：如果在源文件中声明和定义函数，我们需要确保在使用之前函数已经被声明。

  • 头文件（.h）声明和源文件（.cpp）定义示例


基本语法

// 返回类型 函数名(参数类型 参数名1, 参数类型 参数名2, .......)
{
      函数的代码逻辑;
      函数的代码逻辑;
      函数的代码逻辑;
      .............
      return 返回值;(如果有返回类型才返回)
}
  • 返回类型：可以写任意的变量类型（例如：int、float、double、char、bool、string等）以及复杂数据类型（数组、枚举、结构体、类、指针）。
  • void：代表没有任何返回值。当函数不返回信息，仅处理逻辑时，可以写void来表示没有返回值。
  • 函数名：可以使用帕斯卡命名法（Pascal Case）或驼峰命名法（Camel Case）进行命名。例如：MyName（帕斯卡命名法），myName（驼峰命名法）。
  • 参数：参数不是必须的，可以有0~n个参数，参数的类型可以是任意类型。多个参数之间用逗号隔开。参数名一般使用驼峰命名法。
  • 返回值：当返回值不为void时，必须使用return关键字返回对应类型的内容。即使使用了void代表没有返回值，我们也可以通过return语句提前结束函数。

实际运用

函数声明

// 函数声明
// 保证之后要使用的函数在此处声明

// 1. 只进行函数声明，只包括返回值、函数名、参数，不包含方法体，逗号隔开
void sayHellow();
void sayYourName(string name);
string whatYourName();
int sum(int a, int b);

// 2. 进行函数声明时，同时定义，包括方法体和函数逻辑
void sayHello2()
{
    // 函数逻辑
    cout << "你好世界" << endl;
    cout << "韬老狮" << endl;
    cout << "123" << endl;
    int i = 4 + 5;
    cout << i << endl;
    // return 返回值;
}

函数定义

  1. 无参无返回值函数
void sayHellow()
{
    // 函数逻辑
    cout << "你好世界" << endl;
    cout << "韬老狮" << endl;
    cout << "123" << endl;
    int i = 4 + 5;
    cout << i << endl;
    // return 返回值;
}
  1. 有参无返回值函数
void sayYourName(string name)
{
    cout << "你的名字是" << name << endl;
    // return 返回值;
}
  1. 无参有返回值函数
string whatYourName()
{
    string str = "韬老狮";
    // return 返回值;
    return str;
}
  1. 有参有返回值函数
int sum(int a, int b)
{
    return a + b;
}

函数使用

  • 无参无返回值函数的调用 

    sayHellow();
// 你好世界
// 韬老狮
// 123
// 9
sayHello2();
// 你好世界
// 韬老狮
// 123
// 9

  • 有参无返回值函数的调用 

    sayYourName("韬老狮");  // 你的名字是韬老狮

string str = "韬老狮2";
sayYourName(str);  // 你的名字是韬老狮2

sayYourName(whatYourName());  // 你的名字是韬老狮

  • 调用一个无参有返回值的函数 

    string name = whatYourName();
cout << name << endl;  // 韬老狮

cout << sum(5, 5) << endl;  // 10
cout << sum(3, 2) << endl;  // 5
cout << sum(123, 9999) << endl;  // 10122

关于 return

即使函数没有返回值，我们也可以使用return。
return可以直接不执行之后的代码，直接返回到函数外部。

函数声明

void speak(string str);

函数定义

void speak(string str)
{
    if (str == "混蛋")
        return;
    cout << str << endl;
}

函数使用

speak("混蛋");  // 不会输出混蛋
speak("韬老狮，我爱你");  // 韬老狮，我爱你

总结

  • 基本概念：函数（方法）是封装代码进行重复使用的一种机制。
  • 函数声明和定义：标准做法是函数声明在头文件（.h）中，定义在源文件（.cpp）中。但目前我们可以在源文件（.cpp）中声明和定义函数。
  • 基本语法：返回类型、函数名、参数、方法体以及return的使用。
  • return的作用：return不仅用于返回值，也可用于提前结束函数逻辑，程序是从上往下执行的。

2.2 知识点代码

Lesson02_函数_函数基础.cpp

#include <iostream>
#include "CustomConsole.h"
using namespace std;

//函数声明
//保证之后要使用的函数在此处声明

//1.只进行函数声明 只包括 返回值 函数名 参数 不包含方法体 逗号隔开
void sayHellow();
void sayYourName(string name);
string whatYourName();
int sum(int a, int b);
void speak(string str);

//2. 进行函数声明时 同时定义 包括方法体和函数逻辑
void sayHello2()
{
    //函数逻辑
    cout << "你好世界" << endl;
    cout << "韬老狮" << endl;
    cout << "123" << endl;
    int i = 4 + 5;
    cout << i << endl;
    //4
    //return 返回值;
}

int main()
{
    std::cout << "函数基础\n";

    //无参无返回值函数的调用
    sayHellow();
    //你好世界
    //韬老狮
    //123
    //9
    sayHello2();
    //你好世界
    //韬老狮
    //123
    //9

    //有参无返回值函数的调用
    //1.常量
    //2.变量
    //3.返回对应值的表达式（函数、一些拼接或者计算结果）
    sayYourName("韬老狮");//你的名字是韬老狮

    string str = "韬老狮2";
    sayYourName(str);//你的名字是韬老狮2

    sayYourName(whatYourName());//你的名字是韬老狮

    //调用一个无参有返回值的函数
    //一般很少这样写 因为我们并没有使用它的返回值
    //whatYourName();
    //一般有返回值的函数 都会使用它的返回值
    string name = whatYourName();
    cout << name << endl;//韬老狮

    cout << sum(5, 5) << endl;//10
    cout << sum(3, 2) << endl;//5
    cout << sum(123, 9999) << endl;//10122

    speak("混蛋");//不会输出混蛋
    speak("韬老狮，我爱你");//韬老狮，我爱你

}

#pragma region 知识点一 基本概念

//函数（方法）
//本质是一块具有名称的代码块
//可以使用函数（方法）的名称来执行该代码块
//函数（方法）是封装代码进行重复使用的一种机制

//函数（方法）的主要作用
//1.封装代码
//2.提升代码复用率（少写点代码）
//3.抽象行为

#pragma endregion

#pragma region 知识点二 函数在哪里声明

//标准的做法是
//函数的声明一般在头文件(.h)
//函数的定义一般在源文件(.cpp)

//我们目前还没有学习头文件和源文件的知识
//因此我们直接将函数声明和定义在源文件(.cpp)中
//注意：
//如果在源文件中声明和定义函数，我们需要确保在使用之前函数已经被声明

#pragma endregion

#pragma region 知识点三 基本语法

//    1      2      3
// 返回类型 函数名(参数类型 参数名1, 参数类型 参数名2, .......)
//{
//      函数的代码逻辑;
//      函数的代码逻辑;
//      函数的代码逻辑;
//      .............
//       4
//      return 返回值;(如果有返回类型才返回)
//}
//1-1.返回类型 可以写任意的变量类型 
//    14种变量类型(int、float、double、char、bool、string) + 复杂数据类型（数组、枚举、结构体、类、指针）
//1-2.void关键字 代表没有任何返回值 当函数不返回信息时 只是处理逻辑时 就可以写void代表没有返回值 

//2.关于函数名 可以使用帕斯卡命名法 或者 驼峰命名法 来进行函数命名（根据公司团队来定）
//	MyName(帕斯卡命名法)  myName(驼峰命名法)

//3-1.参数不是必须的，可以有0~n个参数 参数的类型也是可以是任意的类型 
//	  14种变量类型(int、float、double、char、bool、string) + 复杂数据类型（数组、枚举、结构体、类、指针）
//    多个参数之间 用逗号隔开
//3-2.参数名一般使用驼峰命名法

//4.当返回值不为void时 那么就必须通过新的关键字 return返回对应类型的内容
//	注意：即使我们使用了void代表没有返回值 我们也是可以通过return返回的

#pragma endregion

#pragma region 知识点四 实际运用

//1.无参无返回值函数
//1       2    3 
void sayHellow()
{
    //函数逻辑
    cout << "你好世界" << endl;
    cout << "韬老狮" << endl;
    cout << "123" << endl;
    int i = 4 + 5;
    cout << i << endl;
    //4
    //return 返回值;
}

//2.有参无返回值函数
//1     2            3
void sayYourName(string name)
{
    cout << "你的名字是" << name << endl;

    //4
    //return 返回值;
}

//3.无参有返回值函数
//1        2        3
string whatYourName()
{
    string str = "韬老狮";
    //4
    return str;
    //return "韬老狮";

    //如果函数其中存在条件分支语句 那么一定要保证每种情况都有返回值
    //目的就是让函数 一定得返回内容
    /*int i = 10;
    if (i < 10)
        return "韬老狮10";
    else
        return "";*/

}

//4.有参有返回值函数
//1  2    3
int sum(int a, int b)
{
    //int c = a + b;
    //4 return 
    //return c;
    // return 后面可以写一个表达式 只要这个表达式的结果和返回类型一致即可
    return a + b;
}

#pragma endregion

#pragma region 知识点五 关于return

//即使函数没有返回值，我们也可以使用return，
//return可以直接不执行之后的代码，直接返回到函数外部

void speak(string str)
{
    if (str == "混蛋")
        return;
    cout << str << endl;
}

#pragma endregion

#pragma region 总结

//1.基本概念
//2.函数写在哪里 .h声明.cpp中定义 但是我们目前学习 声明和定义都可以在.cpp当中完成
//3.基本语法 1 2 3 4
//4.return 可以提前结束函数逻辑 程序是线性执行的 从上往下执行的

#pragma endregion

2.3 练习题

写一个函数，比较两个数字的大小，返回最大值

函数声明

// 函数声明
int checkMax(int a, int b);

函数定义

int checkMax(int a, int b)
{
    // 第一种写法
    /*if (a > b)
        return a;
    else
        return b;*/
    
    // 第二种写法
    /*if (a > b)
        return a;
    
    return b;*/
    
    // 第三种写法
    return a > b ? a : b;
}

函数使用

int result = checkMax(5, 4);
cout << result << endl; // 5

int a = 99;
int b = 188;
result = checkMax(a, b);
cout << result << endl; // 188

写一个函数，用于计算一个圆的面积和周长，并打印

函数声明

// 函数声明
void calcCirc(float r);

函数定义

// 面积：πr² 周长：2πr
// 需要传入一个参数 （圆的半径）
void calcCirc(float r)
{
    // 面积
    float m = 3.14f * r * r;
    // 周长
    float z = 2 * 3.14f * r;

    cout << "半径为" << r << "的圆，其面积是：" << m << "，周长是：" << z << endl;
}

函数使用

calcCirc(5);
// 该圆的面积是：78.5，周长是：31.4

calcCirc(2.5f);
// 该圆的面积是：19.625，周长是：15.7

写一个函数，判断你传入的参数是不是质数

函数声明

// 函数声明
bool isPrime(unsigned num);

函数定义

// 质数：一个只能被1和自己整除的数 大于1的自然数
// 是不是 - bool类型作为函数返回值 true代表是 false代表不是
// 参数类型：unsigned
bool isPrime(unsigned num)
{
    // 前面去判断这个数 是不是质数
    // 得到2到num-1之间的数
    for (int i = 2; i < num; i++)
    {
        // 用得到的数去和原本的数取余
        // 如果==0，证明它能够被之间的数整除
        if (num % i == 0)
            return false;
    }

    // 默认传入的数就是质数
    return true;
}

函数使用

bool bo = isPrime(17);
if (bo)
    cout << "17是质数" << endl; // 输出：17是质数
else
    cout << "17不是质数" << endl;

写一个函数，判断你输入的年份是否是闰年

闰年判断条件：

  • 年份能被400整除（2000）
  • 或者年份能被4整除，但是不能被100整除（2008）

函数声明

// 函数声明
bool isLeapYear(unsigned year);

函数定义

bool isLeapYear(unsigned year)
{
    // 只有满足了一定得条件才是闰年
    if (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0))
        return true;
    // 默认不是闰年
    return false;
}

函数使用

bo = isLeapYear(2007);
if (bo)
    cout << "2007是闰年" << endl;
else
    cout << "2007不是闰年" << endl; // 输出：2007不是闰年

2.4 练习题代码

Lesson02_练习题.cpp

#include <iostream>
using namespace std;

#pragma region 练习题一
// 函数声明
int checkMax(int a, int b);
#pragma endregion

#pragma region 练习题二
// 函数声明
void calcCirc(float r);
#pragma endregion

#pragma region 练习题三
// 函数声明
bool isPrime(unsigned num);
#pragma endregion

#pragma region 练习题四
// 函数声明
bool isLeapYear(unsigned year);
#pragma endregion

int main()
{
    std::cout << "函数 练习题\n";

    // 练习题一
    #pragma region 练习题一

    int result = checkMax(5, 4);
    cout << result << endl; // 5
    int a = 99;
    int b = 188;
    result = checkMax(a, b);
    cout << result << endl; // 188

    #pragma endregion

    // 练习题二
    #pragma region 练习题二
    calcCirc(5);
    // 该圆的面积是：78.5，周长是：31.4
    calcCirc(2.5f);
    // 该圆的面积是：19.625，周长是：15.7
    #pragma endregion

    // 练习题三
    #pragma region 练习题三
    bool bo = isPrime(17);
    if (bo)
        cout << "17是质数" << endl; // 输出：17是质数
    else
        cout << "17不是质数" << endl;
    #pragma endregion

    // 练习题四
    #pragma region 练习题四
    bo = isLeapYear(2007);
    if (bo)
        cout << "2007是闰年" << endl;
    else
        cout << "2007不是闰年" << endl; // 输出：2007不是闰年
    #pragma endregion
}

// 练习题一
#pragma region 练习题一
// 写一个函数，比较两个数字的大小，返回最大值

int checkMax(int a, int b)
{
    // 第一种写法
    /*if (a > b)
        return a;
    else
        return b;*/

    // 第二种写法
    /*if (a > b)
        return a;

    return b;*/
    // 第三种写法
    return a > b ? a : b;
}
#pragma endregion

// 练习题二
#pragma region 练习题二
// 写一个函数，用于计算一个圆的面积和周长，并打印
// 面积：πr² 周长：2πr
// 需要传入一个参数 （圆的半径）
void calcCirc(float r)
{
    // 面积
    float m = 3.14f * r * r;
    // 周长
    float z = 2 * 3.14f * r;

    cout << "半径为" << r << "的圆，其面积是：" << m << "，周长是：" << z << endl;
}
#pragma endregion

// 练习题三
#pragma region 练习题三
// 写一个函数，判断你传入的参数是不是质数
// 质数：一个只能被1和自己整除的数 大于1的自然数
// 是不是 - bool类型作为函数返回值 true代表是 false代表不是
// 参数类型：unsigned
bool isPrime(unsigned num)
{
    // 前面去判断这个数 是不是质数
    // 得到2到num-1之间的数
    for (int i = 2; i < num; i++)
    {
        // 用得到的数去和原本的数取余
        // 如果==0，证明它能够被之间的数整除
        if (num % i == 0)
            return false;
    }

    // 默认传入的数就是质数
    return true;
}
#pragma endregion

// 练习题四
#pragma region 练习题四
// 写一个函数，判断你输入的年份是否是闰年
// 闰年判断条件：
// 年份能被400整除（2000）
// 或者
// 年份能被4整除，但是不能被100整除（2008）
// 通过是否 可以分析出 我们的返回值 可以使使用 bool true是闰年 false 就不是闰年
// 参数类型因为不会是负数 unsigned
bool isLeapYear(unsigned year)
{
    // 只有满足了一定得条件才是闰年
    if (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0))
        return true;
    // 默认不是闰年
    return false;
}
#pragma endregion
转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 785293209@qq.com

赏

©2016-2024 Tao

Built with Hexo and 3-hexo theme

×

喜欢就点赞,疼爱就打赏