C++函数返回普通类型的应用场景

简单数据处理与结果反馈

在许多基础的编程任务中，我们经常需要对一些简单的数据进行处理，并返回处理结果。例如，计算两个整数的和、差、积、商等基本运算。在 C++ 中，函数返回普通类型能够很好地满足这类需求。

基本数学运算函数

以加法运算为例，我们可以定义一个函数 add，它接受两个整数参数，并返回它们的和。

#include <iostream>

// 定义一个返回整数和的函数
int add(int a, int b) {
    return a + b;
}

int main() {
    int num1 = 5;
    int num2 = 3;
    int result = add(num1, num2);
    std::cout << "The sum of " << num1 << " and " << num2 << " is " << result << std::endl;
    return 0;
}

在上述代码中，add 函数返回一个普通的 int 类型，即两个整数参数的和。main 函数调用 add 函数并将返回值赋给 result 变量，然后输出结果。

对于减法、乘法和除法运算，也可以采用类似的方式定义函数。

// 减法函数
int subtract(int a, int b) {
    return a - b;
}

// 乘法函数
int multiply(int a, int b) {
    return a * b;
}

// 除法函数，这里简单处理了除数为0的情况
double divide(int a, int b) {
    if (b == 0) {
        std::cerr << "Error: division by zero" << std::endl;
        return 0.0;
    }
    return static_cast<double>(a) / b;
}

这些函数分别返回两个整数运算后的结果，返回类型根据运算的性质可能是 int 或 double。这种简单的函数返回普通类型在数学计算相关的程序中应用广泛，无论是简单的计算器程序，还是更复杂的科学计算库的底层实现。

数据验证与标志返回

有时候，我们需要在函数中验证输入数据的有效性，并通过返回值来告知调用者验证结果。例如，验证一个字符串是否符合特定的格式，如是否为有效的邮箱地址格式。虽然在实际应用中可能会使用更复杂的正则表达式库，但我们可以通过简单的字符检查来展示这种应用场景。

#include <iostream>
#include <string>

// 简单验证字符串是否只包含字母和数字
bool isValidAlphanumeric(const std::string& str) {
    for (char c : str) {
        if (!std::isalnum(c)) {
            return false;
        }
    }
    return true;
}

int main() {
    std::string testStr1 = "abc123";
    std::string testStr2 = "abc!123";
    if (isValidAlphanumeric(testStr1)) {
        std::cout << testStr1 << " is valid" << std::endl;
    } else {
        std::cout << testStr1 << " is not valid" << std::endl;
    }
    if (isValidAlphanumeric(testStr2)) {
        std::cout << testStr2 << " is valid" << std::endl;
    } else {
        std::cout << testStr2 << " is not valid" << std::endl;
    }
    return 0;
}

在这个例子中，isValidAlphanumeric 函数返回一个 bool 类型的值，表示输入的字符串是否只包含字母和数字。main 函数根据返回值输出相应的提示信息。这种返回普通类型（这里是 bool）用于验证和标志的方式，在数据输入校验、程序流程控制等方面非常有用。例如，在用户登录系统中验证用户名和密码是否符合格式要求，或者在文件读取中验证文件格式是否正确等场景。

数据检索与查找

在处理数据集合时，我们常常需要从集合中查找特定的数据，并返回查找到的结果。C++ 函数返回普通类型在这种场景下也发挥着重要作用。

在数组中查找元素

假设有一个整数数组，我们想要查找某个特定的整数，并返回其在数组中的位置（如果找到）。如果没有找到，则返回一个特殊的值，比如 -1。

#include <iostream>

// 在整数数组中查找元素并返回其位置
int findElementInArray(int arr[], int size, int target) {
    for (int i = 0; i < size; ++i) {
        if (arr[i] == target) {
            return i;
        }
    }
    return -1;
}

int main() {
    int numbers[] = {10, 20, 30, 40, 50};
    int target = 30;
    int position = findElementInArray(numbers, sizeof(numbers) / sizeof(numbers[0]), target);
    if (position != -1) {
        std::cout << "Element " << target << " found at position " << position << std::endl;
    } else {
        std::cout << "Element " << target << " not found" << std::endl;
    }
    return 0;
}

在上述代码中，findElementInArray 函数返回一个 int 类型的值，表示目标元素在数组中的位置。如果没有找到目标元素，则返回 -1。这种返回普通类型用于数据查找结果反馈的方式，在各种数据结构（如数组、链表等）的查找操作中经常使用。

在字典（哈希表）模拟查找

虽然 C++ 标准库提供了 std::unordered_map 等哈希表容器，但我们可以通过简单的数组模拟一个字典结构，并实现查找功能。例如，我们将一些单词和对应的解释存储在两个数组中，模拟一个简单的字典，然后根据单词查找对应的解释。

#include <iostream>
#include <string>

// 模拟字典查找，返回单词的解释
std::string findWordExplanation(const std::string words[], const std::string explanations[], int size, const std::string& word) {
    for (int i = 0; i < size; ++i) {
        if (words[i] == word) {
            return explanations[i];
        }
    }
    return "Word not found";
}

int main() {
    std::string words[] = {"apple", "banana", "cherry"};
    std::string explanations[] = {"A round fruit", "A long yellow fruit", "A small red fruit"};
    std::string searchWord = "banana";
    std::string explanation = findWordExplanation(words, explanations, sizeof(words) / sizeof(words[0]), searchWord);
    std::cout << "Explanation of " << searchWord << " is: " << explanation << std::endl;
    return 0;
}

在这个例子中，findWordExplanation 函数返回一个 std::string 类型的值，即目标单词的解释。如果没有找到目标单词，则返回 "Word not found"。这种方式类似于在实际的字典应用程序或者翻译软件中的查找功能实现，通过函数返回普通类型（这里是 std::string）来提供查找结果。

计算与统计

在数据处理和分析场景中，经常需要进行各种计算和统计操作，并返回统计结果。C++ 函数返回普通类型为实现这类功能提供了便利。

数组元素统计

比如，我们想要统计一个整数数组中所有元素的总和、平均值、最大值和最小值等。可以分别定义不同的函数来完成这些统计操作。

#include <iostream>

// 计算数组元素总和
int sumArray(int arr[], int size) {
    int sum = 0;
    for (int i = 0; i < size; ++i) {
        sum += arr[i];
    }
    return sum;
}

// 计算数组元素平均值
double averageArray(int arr[], int size) {
    int sum = sumArray(arr, size);
    if (size == 0) {
        return 0.0;
    }
    return static_cast<double>(sum) / size;
}

// 找到数组中的最大值
int maxInArray(int arr[], int size) {
    if (size == 0) {
        return 0;
    }
    int max = arr[0];
    for (int i = 1; i < size; ++i) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    return max;
}

// 找到数组中的最小值
int minInArray(int arr[], int size) {
    if (size == 0) {
        return 0;
    }
    int min = arr[0];
    for (int i = 1; i < size; ++i) {
        if (arr[i] < min) {
            min = arr[i];
        }
    }
    return min;
}

int main() {
    int numbers[] = {10, 20, 30, 40, 50};
    int size = sizeof(numbers) / sizeof(numbers[0]);
    int sum = sumArray(numbers, size);
    double average = averageArray(numbers, size);
    int max = maxInArray(numbers, size);
    int min = minInArray(numbers, size);
    std::cout << "Sum: " << sum << std::endl;
    std::cout << "Average: " << average << std::endl;
    std::cout << "Max: " << max << std::endl;
    std::cout << "Min: " << min << std::endl;
    return 0;
}

上述代码中，sumArray 函数返回数组元素的总和，类型为 int；averageArray 函数返回数组元素的平均值，类型为 double；maxInArray 和 minInArray 函数分别返回数组中的最大值和最小值，类型为 int。这些函数通过返回普通类型，方便地提供了数组元素的各种统计信息，在数据分析、算法实现等领域有广泛应用。

字符串统计

对于字符串，我们也可能需要进行一些统计操作，比如统计字符串中某个字符出现的次数。

#include <iostream>
#include <string>

// 统计字符串中某个字符出现的次数
int countCharInString(const std::string& str, char targetChar) {
    int count = 0;
    for (char c : str) {
        if (c == targetChar) {
            count++;
        }
    }
    return count;
}

int main() {
    std::string testStr = "hello world";
    char targetChar = 'l';
    int charCount = countCharInString(testStr, targetChar);
    std::cout << "The character '" << targetChar << "' appears " << charCount << " times in the string" << std::endl;
    return 0;
}

在这个例子中，countCharInString 函数返回一个 int 类型的值，表示目标字符在字符串中出现的次数。这种对字符串进行统计并返回普通类型结果的方式，在文本处理、信息检索等方面都有重要应用，比如统计一篇文章中某个关键词出现的频率等。

状态反馈与控制

在程序执行过程中，函数可能需要返回一些状态信息，以帮助调用者决定后续的执行流程。同时，函数返回普通类型也可以用于控制程序的一些行为。

函数执行状态返回

比如，在文件操作中，打开文件的函数可能会返回一个状态码，用于表示文件是否成功打开。

#include <iostream>
#include <fstream>

// 打开文件并返回状态码
int openFile(const std::string& filename, std::ifstream& file) {
    file.open(filename);
    if (file.is_open()) {
        return 0; // 成功
    } else {
        return -1; // 失败
    }
}

int main() {
    std::ifstream myFile;
    std::string filename = "test.txt";
    int status = openFile(filename, myFile);
    if (status == 0) {
        std::cout << "File opened successfully" << std::endl;
        // 进行文件读取等操作
        myFile.close();
    } else {
        std::cout << "Failed to open file" << std::endl;
    }
    return 0;
}

在上述代码中，openFile 函数返回一个 int 类型的状态码，0 表示文件成功打开，-1 表示打开失败。main 函数根据返回的状态码决定后续的操作，这种通过返回普通类型来反馈函数执行状态的方式在许多系统调用、库函数等场景中都非常常见，有助于程序进行错误处理和流程控制。

条件控制返回

考虑一个函数，它根据某个条件返回不同的值，以控制程序的行为。例如，根据用户的权限级别返回不同的操作结果。

#include <iostream>

// 根据权限级别返回操作结果
int performAction(int privilegeLevel) {
    if (privilegeLevel >= 10) {
        return 1; // 允许执行操作
    } else {
        return 0; // 不允许执行操作
    }
}

int main() {
    int userPrivilege = 5;
    int result = performAction(userPrivilege);
    if (result == 1) {
        std::cout << "You are allowed to perform the action" << std::endl;
    } else {
        std::cout << "You do not have sufficient privilege" << std::endl;
    }
    return 0;
}

在这个例子中，performAction 函数根据传入的权限级别返回 0 或 1，main 函数根据返回值决定是否允许用户执行某个操作。这种通过函数返回普通类型进行条件控制的方式，在访问控制、流程决策等程序设计环节中广泛应用，使得程序能够根据不同的条件做出相应的反应。

数据转换与格式化

在编程中，经常需要将一种数据类型转换为另一种数据类型，或者对数据进行格式化处理，并返回处理后的结果。C++ 函数返回普通类型在这些场景中起到关键作用。

数据类型转换

例如，将一个整数转换为字符串，或者将字符串转换为整数。C++ 标准库提供了一些函数来完成这些操作，但我们也可以自己实现简单的转换函数。

#include <iostream>
#include <string>

// 将整数转换为字符串
std::string intToString(int num) {
    std::string result;
    if (num == 0) {
        result = "0";
    } else {
        bool isNegative = num < 0;
        if (isNegative) {
            num = -num;
        }
        while (num > 0) {
            int digit = num % 10;
            result = static_cast<char>(digit + '0') + result;
            num /= 10;
        }
        if (isNegative) {
            result = "-" + result;
        }
    }
    return result;
}

// 将字符串转换为整数
int stringToInt(const std::string& str) {
    int result = 0;
    int sign = 1;
    int i = 0;
    if (str[0] == '-') {
        sign = -1;
        i = 1;
    }
    for (; i < str.length(); ++i) {
        if (!std::isdigit(str[i])) {
            std::cerr << "Invalid string for conversion" << std::endl;
            return 0;
        }
        result = result * 10 + (str[i] - '0');
    }
    return result * sign;
}

int main() {
    int num = 123;
    std::string str = intToString(num);
    std::cout << num << " converted to string: " << str << std::endl;
    std::string testStr = "456";
    int convertedNum = stringToInt(testStr);
    std::cout << testStr << " converted to int: " << convertedNum << std::endl;
    return 0;
}

在上述代码中，intToString 函数将一个 int 类型转换为 std::string 类型并返回，stringToInt 函数则将一个表示整数的字符串转换为 int 类型并返回。这种数据类型转换并返回普通类型结果的函数在数据处理、输入输出等方面经常用到，比如将用户输入的字符串转换为数字进行计算，或者将计算结果转换为字符串进行显示。

数据格式化

对于日期、时间等数据，我们可能需要将其格式化为特定的字符串形式。假设我们有一个简单的日期结构体，并且想要将其格式化为 "YYYY - MM - DD" 的字符串形式。

#include <iostream>
#include <string>

struct Date {
    int year;
    int month;
    int day;
};

// 将日期格式化为字符串
std::string formatDate(const Date& date) {
    std::string result;
    result += std::to_string(date.year) + " - ";
    if (date.month < 10) {
        result += "0";
    }
    result += std::to_string(date.month) + " - ";
    if (date.day < 10) {
        result += "0";
    }
    result += std::to_string(date.day);
    return result;
}

int main() {
    Date myDate = {2023, 10, 5};
    std::string formattedDate = formatDate(myDate);
    std::cout << "Formatted date: " << formattedDate << std::endl;
    return 0;
}

在这个例子中，formatDate 函数接受一个 Date 结构体，并将其格式化为特定的字符串形式后返回。这种数据格式化并返回普通类型（这里是 std::string）的方式在数据展示、日志记录等场景中非常有用，能够以符合人类阅读习惯或特定系统要求的格式呈现数据。

中间计算结果传递

在复杂的计算过程中，函数可能需要返回中间计算结果，以便后续的函数继续使用这些结果进行进一步的计算。这种通过返回普通类型传递中间结果的方式，有助于构建模块化的计算流程。

数学公式计算中的中间结果

例如，计算一个复杂的数学公式，如计算两点之间的欧几里得距离公式 $d = \sqrt{(x_1 - x_2)^2 + (y_1 - y_2)^2}$。我们可以将公式分解为几个步骤，每个步骤的计算结果作为中间结果返回。

#include <iostream>
#include <cmath>

// 计算差值的平方
double squareDifference(double a, double b) {
    double diff = a - b;
    return diff * diff;
}

// 计算欧几里得距离
double euclideanDistance(double x1, double y1, double x2, double y2) {
    double sumOfSquares = squareDifference(x1, x2) + squareDifference(y1, y2);
    return std::sqrt(sumOfSquares);
}

int main() {
    double x1 = 1.0, y1 = 2.0, x2 = 4.0, y2 = 6.0;
    double distance = euclideanDistance(x1, y1, x2, y2);
    std::cout << "The Euclidean distance between (" << x1 << ", " << y1 << ") and (" << x2 << ", " << y2 << ") is " << distance << std::endl;
    return 0;
}

在上述代码中，squareDifference 函数返回两个数差值的平方，这个结果作为中间结果被 euclideanDistance 函数使用，最终 euclideanDistance 函数返回两点之间的欧几里得距离。这种通过函数返回普通类型（这里是 double）传递中间计算结果的方式，使得复杂的计算过程更加清晰和模块化，易于维护和扩展。

数据处理流水线中的中间结果

在数据处理流水线中，例如对图像数据进行一系列处理，可能先对图像进行灰度化处理，然后进行边缘检测。灰度化处理的结果作为中间结果传递给边缘检测函数。

#include <iostream>
#include <vector>

// 假设这是一个简单的图像表示，二维数组表示像素值
using Image = std::vector<std::vector<int>>;

// 灰度化处理，返回灰度化后的图像
Image grayscaleImage(const Image& originalImage) {
    Image grayscaleImage = originalImage;
    for (size_t i = 0; i < originalImage.size(); ++i) {
        for (size_t j = 0; j < originalImage[i].size(); ++j) {
            // 简单的灰度化公式，取RGB平均值
            int pixelValue = (originalImage[i][j] + originalImage[i][j] + originalImage[i][j]) / 3;
            grayscaleImage[i][j] = pixelValue;
        }
    }
    return grayscaleImage;
}

// 简单的边缘检测，这里只是示例，实际可能更复杂
Image edgeDetection(const Image& grayscaleImage) {
    Image edgeImage = grayscaleImage;
    for (size_t i = 1; i < grayscaleImage.size() - 1; ++i) {
        for (size_t j = 1; j < grayscaleImage[i].size() - 1; ++j) {
            int gradientX = grayscaleImage[i + 1][j] - grayscaleImage[i - 1][j];
            int gradientY = grayscaleImage[i][j + 1] - grayscaleImage[i][j - 1];
            int edgeMagnitude = std::abs(gradientX) + std::abs(gradientY);
            edgeImage[i][j] = edgeMagnitude > 50? 255 : 0;
        }
    }
    return edgeImage;
}

int main() {
    // 简单初始化一个图像
    Image originalImage = {
        {100, 120, 130},
        {140, 150, 160},
        {170, 180, 190}
    };
    Image grayscale = grayscaleImage(originalImage);
    Image edges = edgeDetection(grayscale);
    // 这里可以进一步处理或显示边缘图像
    return 0;
}

在这个图像数据处理的例子中，grayscaleImage 函数返回灰度化后的图像（一个 Image 类型，这里简单用二维 std::vector<int> 表示），这个结果作为中间结果传递给 edgeDetection 函数进行边缘检测。通过函数返回普通类型（这里是自定义的 Image 类型）来传递中间结果，有助于构建复杂的数据处理流程，每个处理步骤可以独立开发和测试，提高了代码的可维护性和复用性。

缓存与复用

在一些情况下，函数返回的普通类型结果可能会被缓存起来，以便在后续的计算中复用，从而提高程序的效率。

计算结果缓存

例如，计算斐波那契数列的函数。斐波那契数列的计算具有重复性，我们可以缓存已经计算过的结果，避免重复计算。

#include <iostream>
#include <vector>

// 缓存斐波那契数列结果
std::vector<int> fibonacciCache;

// 计算斐波那契数列第n项
int fibonacci(int n) {
    if (n <= 1) {
        return n;
    }
    if (fibonacciCache.size() <= n) {
        fibonacciCache.resize(n + 1);
        fibonacciCache[0] = 0;
        fibonacciCache[1] = 1;
        for (int i = 2; i <= n; ++i) {
            fibonacciCache[i] = fibonacciCache[i - 1] + fibonacciCache[i - 2];
        }
    }
    return fibonacciCache[n];
}

int main() {
    int n = 10;
    int result = fibonacci(n);
    std::cout << "The " << n << "th Fibonacci number is " << result << std::endl;
    return 0;
}

在上述代码中，fibonacci 函数返回斐波那契数列的第 n 项。通过使用 fibonacciCache 缓存已经计算过的结果，当再次计算相同项时，可以直接从缓存中获取，而不需要重新计算，大大提高了计算效率。这种通过缓存函数返回的普通类型结果（这里是 int）来提高复用性的方式，在许多具有重复性计算的场景中都非常有效，如动态规划算法中的子问题计算。

资源获取结果缓存

在获取一些资源（如数据库连接、文件句柄等）时，我们可能希望缓存获取结果，以避免重复获取资源带来的开销。假设我们有一个函数用于获取数据库连接。

#include <iostream>
// 这里假设这是数据库连接相关的头文件
#include <mysql/mysql.h>

// 缓存数据库连接
MYSQL* databaseConnectionCache = nullptr;

// 获取数据库连接
MYSQL* getDatabaseConnection() {
    if (databaseConnectionCache == nullptr) {
        databaseConnectionCache = mysql_init(nullptr);
        if (databaseConnectionCache == nullptr) {
            std::cerr << "mysql_init() failed" << std::endl;
            return nullptr;
        }
        if (mysql_real_connect(databaseConnectionCache, "localhost", "user", "password", "database", 0, nullptr, 0) == nullptr) {
            std::cerr << "mysql_real_connect() failed" << std::endl;
            mysql_close(databaseConnectionCache);
            return nullptr;
        }
    }
    return databaseConnectionCache;
}

int main() {
    MYSQL* connection1 = getDatabaseConnection();
    // 使用连接1进行数据库操作
    MYSQL* connection2 = getDatabaseConnection();
    // connection2 和 connection1 是同一个连接，避免了重复连接数据库的开销
    if (connection1 != nullptr) {
        mysql_close(connection1);
    }
    return 0;
}

在这个例子中，getDatabaseConnection 函数返回一个数据库连接（MYSQL* 类型，这里是普通指针类型，可视为普通类型的一种变体）。通过缓存连接结果，后续调用 getDatabaseConnection 函数时，如果缓存中有连接，则直接返回缓存的连接，减少了重复获取数据库连接的开销，提高了程序性能。这种缓存函数返回普通类型（这里是 MYSQL*）结果的方式，在资源管理和复用方面具有重要意义，特别是在需要频繁获取相同资源的场景中。

函数式编程风格应用

在 C++ 中，虽然它不是纯粹的函数式编程语言，但也可以借鉴函数式编程的一些理念。函数返回普通类型在这种应用场景中也有独特的作用。

纯函数与不可变数据

纯函数是指函数的返回值仅取决于输入参数，并且没有副作用。例如，计算两个数乘积的函数就是一个纯函数。

#include <iostream>

// 纯函数，计算两个数的乘积
int multiplyPure(int a, int b) {
    return a * b;
}

int main() {
    int num1 = 3;
    int num2 = 4;
    int result = multiplyPure(num1, num2);
    std::cout << num1 << " * " << num2 << " = " << result << std::endl;
    return 0;
}

在上述代码中，multiplyPure 函数是一个纯函数，它返回两个整数的乘积，其返回值仅由输入参数 a 和 b 决定，并且没有任何副作用（如修改全局变量等）。这种纯函数返回普通类型的方式在函数式编程风格中很常见，使得代码更易于理解、测试和优化。例如，在并行计算中，纯函数可以安全地在不同线程中执行，因为它们不会相互干扰。

高阶函数与函数组合

高阶函数是指接受一个或多个函数作为参数，或者返回一个函数的函数。在函数式编程中，函数组合是将多个函数组合成一个新函数的技术。例如，我们可以定义一个高阶函数，它接受两个函数作为参数，并返回一个新函数，该新函数先应用第一个函数，再应用第二个函数。

#include <iostream>

// 第一个函数，将整数加倍
int doubleNumber(int num) {
    return num * 2;
}

// 第二个函数，将整数加1
int incrementNumber(int num) {
    return num + 1;
}

// 高阶函数，组合两个函数
auto composeFunctions(int (*func1)(int), int (*func2)(int)) {
    return [func1, func2](int num) {
        return func2(func1(num));
    };
}

int main() {
    auto newFunction = composeFunctions(doubleNumber, incrementNumber);
    int result = newFunction(5);
    std::cout << "Result: " << result << std::endl;
    return 0;
}

在这个例子中，composeFunctions 是一个高阶函数，它返回一个新的函数（通过 lambda 表达式实现）。这个新函数先将输入的整数加倍（应用 doubleNumber 函数），然后再加 1（应用 incrementNumber 函数）。这里虽然返回的是一个函数对象，但函数对象在调用时返回的是普通类型（int）。这种函数式编程风格中通过高阶函数返回可调用对象，最终返回普通类型结果的方式，有助于构建复杂的计算逻辑，提高代码的抽象性和复用性。

与其他语言或系统交互

当 C++ 程序需要与其他编程语言或外部系统进行交互时，函数返回普通类型可以方便地传递数据和结果。

与 Python 交互

在 C++ 和 Python 混合编程的场景中，C++ 函数可以通过特定的库（如 PyBind11）将结果返回给 Python 调用者。假设我们有一个 C++ 函数用于计算两个数的和，并且希望在 Python 中调用它。

首先，安装 PyBind11 库（如果未安装）。然后编写以下 C++ 代码：

#include <pybind11/pybind11.h>

// 定义一个返回整数和的函数
int add(int a, int b) {
    return a + b;
}

PYBIND11_MODULE(example, m) {
    m.def("add", &add, "A function to add two numbers");
}

上述代码使用 PyBind11 将 add 函数暴露给 Python。然后编写 Python 代码调用这个函数：

import example

result = example.add(3, 4)
print("The sum is:", result)

在这个例子中，C++ 函数 add 返回一个普通的 int 类型，通过 PyBind11 库，这个结果可以被 Python 程序获取和使用，实现了 C++ 与 Python 之间的数据交互。

与操作系统交互

在与操作系统交互的场景中，C++ 函数可能需要返回一些状态信息给操作系统。例如，在一个创建进程的函数中，可能返回进程 ID（普通整数类型），以便父进程对新创建的进程进行管理。

#include <iostream>
#include <unistd.h>

// 创建进程并返回进程ID
pid_t createProcess() {
    pid_t pid = fork();
    if (pid < 0) {
        std::cerr << "Fork failed" << std::endl;
    } else if (pid == 0) {
        // 子进程代码
        std::cout << "Child process is running" << std::endl;
        _exit(0);
    } else {
        // 父进程代码
        std::cout << "Parent process, child pid is " << pid << std::endl;
    }
    return pid;
}

int main() {
    pid_t childPid = createProcess();
    // 父进程可以根据childPid进行进一步操作，如等待子进程结束等
    return 0;
}

在上述代码中，createProcess 函数返回一个 pid_t 类型（本质上是整数类型，可视为普通类型）的进程 ID，父进程可以根据这个返回值对新创建的子进程进行管理。这种通过函数返回普通类型与操作系统进行交互和信息传递的方式，在系统编程中非常常见。

通过以上多种应用场景的介绍和代码示例，我们可以看到 C++ 函数返回普通类型在各种编程任务中都扮演着重要角色，无论是简单的数据处理，还是复杂的系统交互和函数式编程应用，合理使用函数返回普通类型能够使程序更加清晰、高效和可维护。