C++从基础语法到递归、重载与宏定义_C/C++

题目及题解

1 判定素数

编写程序，用一个函数判定输入的某个数是否为素数。

#include <iostream>
#include <cmath>
// 判定素数函数
bool isprime(int n) {
    if (n < 2) return false;
    for (int i = 2; i <= sqrt(n); ++i) {
        if (n % i == 0) return false;
    }
    return true;
}
int main()
{
    int num;
    std::cout << "输入一个整数: ";
    std::cin >> num;
    if (isprime(num)) std::cout << num << " 是素数" << std::endl;
    else std::cout << num << " 不是素数" << std::endl;
    return 0;
}

2 统计奇偶数

从键盘依次输入一列整数（输入0结束），编写函数，统计输入的整数序列中的奇数个数和偶数个数，在主函数中调用该函数并求输入的整数序列中的奇数个数和偶数个数。

#include <iostream>
// 统计函数：通过引用返回结果
void countnumber(int &odd, int &even) {
    int val;
    while (std::cin >> val && val != 0) {
        if (val % 2 == 0) even++;
        else odd++;
    }
}
int main() 
{
    int oddcount = 0, evencount = 0;
    std::cout << "请输入一列整数（0结束）: " << std::endl;
    countnumber(oddcount, evencount);
    std::cout << "奇数: " << oddcount << " 个，偶数: " << evencount << " 个" << std::endl;
    return 0;
}

3 带默认参数的阶乘

定义一个带默认参数值的函数求 n ! n! n!，在主函数中调用两次该函数，一次给出实参，另一次不给实参，体会默认值的意义。

#include <iostream>
long long factorial(int n = 5) {
    long long res = 1;
    for (int i = 1; i <= n; ++i) res *= i;
    return res;
}
int main() 
{
    // 给出实参
    std::cout << "3! = " << factorial(3) << std::endl;
    // 不给实参，使用默认值 5
    std::cout << "默认(5!) = " << factorial() << std::endl;
    return 0;
}

4 求a ! + b ! + c ! a! + b! + c!a!+b!+c!

求 a ! + b ! + c ! a!+b!+c! a!+b!+c! 的值，要求用两个函数实现：函数 fac 求 n ! n! n!，函数 add 求三者之和。 a a a、 b b b、 c c c 的值由主函数输入，最终得到的值在主函数中输出。

#include <iostream>
long long fac(int n) {
    long long res = 1;
    for (int i = 1; i <= n; ++i) res *= i;
    return res;
}
long long add(long long x, long long y, long long z) {
    return x + y + z;
}
int main() 
{
    int a, b, c;
    std::cout << "输入 a, b, c: ";
    std::cin >> a >> b >> c;
    std::cout << "结果: " << add(fac(a), fac(b), fac(c)) << std::endl;
    return 0;
}

5 判定闰年

编写一个程序，判定用户输入的年份是否为闰年。闰年的判定用名为 isleapyear 的 bool 型函数实现。

#include <iostream>
bool isleapyear(int year) {
    return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}
int main() 
{
    int y;
    std::cout << "输入年份: ";
    std::cin >> y;
    if (isleapyear(y)) std::cout << "是闰年" << std::endl;
    else std::cout << "不是闰年" << std::endl;
    return 0;
}

6 递归求斐波那契数列

#include <iostream>
int fib(int n) {
    if (n == 1 || n == 2) return 1;
    return fib(n - 1) + fib(n - 2);
}
int main() 
{
    int n;
    std::cout << "输入 n: ";
    std::cin >> n;
    std::cout << "第 " << n << " 个数是: " << fib(n) << std::endl;
    return 0;
}

7 验证哥德巴赫猜想

写一个函数验证哥德巴赫猜想：一个不小于6的偶数可以分解为两个素数之和。要求：在主函数中输入一个偶数 n n n，判定 n n n 与6的大小。如果 n n n 不小于6，则调用函数 gotbaha，在 gotbaha 函数中再调用判定素数的函数 prime，并在主函数中输出“6=3+3”形式的结果。如果 n n n 小于6，则程序结束。

#include <iostream>
#include <cmath>
bool prime(int n) {
    if (n < 2) return false;
    for (int i = 2; i <= sqrt(n); i++) {
        if (n % i == 0) return false;
    }
    return true;
}
void gotbaha(int n) {
    for (int i = 2; i <= n / 2; i++) {
        if (prime(i) && prime(n - i)) {
            std::cout << n << "=" << i << "+" << (n - i) << std::endl;
            return;
        }
    }
}
int main() 
{
    int n;
    std::cout << "输入一个偶数: ";
    std::cin >> n;
    if (n >= 6 && n % 2 == 0) gotbaha(n);
    else std::cout << "程序结束" << std::endl;
    return 0;
}

8 函数重载 add

使用 add 作为重载函数名，分别定义求3个整数之和的函数和求两个浮点数之和的函数，并编程实现。

#include <iostream>
int add(int a, int b, int c) { return a + b + c; }
float add(float a, float b) { return a + b; }
int main() 
{
    std::cout << "3个整数和: " << add(1, 2, 3) << std::endl;
    std::cout << "2个浮点数和: " << add(1.5f, 2.5f) << std::endl;
    return 0;
}

9 内联函数求和

在主函数中输入两个数 m , n m, n m,n，用内联函数求和，并输出结果。

#include <iostream>
inline int getsum(int m, int n) { return m + n; }
int main() 
{
    int m, n;
    std::cin >> m >> n;
    std::cout << "和为: " << getsum(m, n) << std::endl;
    return 0;
}

10 头文件实现最大值

编写一个程序，将求两个实数中较大值的函数放在一个头文件中，在源程序文件中包含该头文件，并实现输入3个实数，求出最大值。

my_max.h

#ifndef my_max_h
#define my_max_h
inline double getmax(double a, double b) { return (a > b) ? a : b; }
#endif

main.cpp

#include <iostream>
#include "my_max.h"
int main() 
{
    double a, b, c;
    std::cin >> a >> b >> c;
    double res = getmax(getmax(a, b), c);
    std::cout << "最大值: " << res << std::endl;
    return 0;
}

11 带参数的宏求乘积

编写一个程序，输入两个整数，求它们的乘积。用带参数的宏实现。

#include <iostream>
#define mul(a, b) ((a) * (b))
int main() 
{
    int x, y;
    std::cin >> x >> y;
    std::cout << "乘积: " << mul(x, y) << std::endl;
    return 0;
}

12 递归逆序输出

编写一个递归函数，将整数的每个位上的数字按相反的顺序输出。例如，输入5678，输出8765。

#include <iostream>
void reverse(int n) {
    if (n == 0) return;
    std::cout << n % 10;
    reverse(n / 10);
}
int main() 
{
    int n;
    std::cout << "输入整数: ";
    std::cin >> n;
    if (n == 0) std::cout << "0";
    else reverse(n);
    std::cout << std::endl;
    return 0;
}