c++之if-else基本应用

C语言中的if-else语句是一种基本的流程控制语句，用于根据条件来选择性地执行一组语句。它的基本语法结构如下：

if (条件) {
    // 条件为真时执行的语句块
}
else {
    // 条件为假时执行的语句块
}

在if-else语句中，条件用于判断是否执行if语句块中的代码。如果条件为真，则执行if语句块中的代码；如果条件为假，则执行else语句块中的代码。

if-else语句的应用非常广泛，常用于根据不同的情况做不同的处理。例如，可以使用if-else来判断一个数是奇数还是偶数：

int num = 7;
if (num % 2 == 0) {
    printf("偶数\n");
}
else {
    printf("奇数\n");
}

在这个例子中，通过判断num除以2的余数是否为0，来确定num是奇数还是偶数。如果余数为0，则输出"偶数"；否则输出"奇数"。

除了简单的条件判断外，if-else还可以嵌套使用，用于处理更加复杂的情况。在嵌套的if-else语句中，可以根据不同的条件进行多级判断，以满足不同的需求。

总而言之，if-else语句在C语言中的基本应用是根据条件选择性地执行一组语句，它可以根据不同的情况进行不同的处理。通过灵活运用if-else语句，我们可以编写出更加灵活和智能的程序。

相关问题

C++写Bellman-Ford

下面是C++实现的Bellman-Ford算法代码：

#include <bits/stdc++.h>
using namespace std;

struct Edge {
    int from, to, dist;
};

const int MAXN = 1005;
const int INF = 0x3f3f3f3f;

int n, m, s;                 // n是点数，m是边数，s是源点
int d[MAXN];                 // d[i]表示从源点s到i的最短距离
Edge edges[MAXN];            // 存储所有边的信息

void BellmanFord() {
    memset(d, INF, sizeof(d));          // 将所有点的距离初始化为INF
    d[s] = 0;                            // 将源点距离初始化为0
    for (int i = 1; i < n; i++) {        // 进行n-1轮松弛操作
        for (int j = 0; j < m; j++) {    // 枚举所有边
            int u = edges[j].from;
            int v = edges[j].to;
            int w = edges[j].dist;
            if (d[u] != INF && d[v] > d[u] + w) {
                d[v] = d[u] + w;         // 松弛操作
            }
        }
    }
}

int main() {
    cin >> n >> m >> s;
    for (int i = 0; i < m; i++) {
        cin >> edges[i].from >> edges[i].to >> edges[i].dist;
    }
    BellmanFord();
    for (int i = 1; i <= n; i++) {
        if (d[i] == INF) {
            cout << "INF ";
        } else {
            cout << d[i] << " ";
        }
    }
    cout << endl;
    return 0;
}

该代码的时间复杂度为O(nm)，其中n和m分别表示点数和边数。在实际应用中，如果图中不存在负环，则算法会在n-1轮松弛操作后得到最短路径；如果存在负环，则算法会一直松弛下去，无法得到最短路径。

使用c++实现SHA-1算法

SHA-1是一种加密哈希算法，它将任意长度的消息压缩为一个160位的消息摘要。下面是使用C++实现SHA-1算法的示例代码：

#include <iostream>
#include <cstring>
#include <cstdint>

// 循环左移函数
#define ROTLEFT(a,b) ((a << b) | (a >> (32-b)))

// 定义常量K
const uint32_t K[] = {
    0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6
};

// SHA-1算法函数
void sha1(uint8_t* message, uint32_t message_length, uint32_t* digest) {
    // 初始化缓冲区
    uint32_t H[] = {
        0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0
    };
    // 计算填充位数
    uint32_t padding_length = 64 - ((message_length + 8) % 64);
    // 填充消息
    uint8_t* padded_message = new uint8_t[message_length + padding_length + 8];
    std::memcpy(padded_message, message, message_length);
    padded_message[message_length] = 0x80;
    std::memset(padded_message + message_length + 1, 0, padding_length - 1);
    // 将消息长度添加到消息末尾
    uint64_t message_bit_length = message_length * 8;
    std::memcpy(padded_message + message_length + padding_length, &message_bit_length, sizeof(message_bit_length));
    // 处理每个512位的分组
    for (uint32_t i = 0; i < message_length + padding_length + 8; i += 64) {
        // 将分组划分为16个32位的字
        uint32_t* w = new uint32_t[80];
        for (uint32_t j = 0; j < 16; j++) {
            w[j] = (padded_message[i + j * 4] << 24) |
                   (padded_message[i + j * 4 + 1] << 16) |
                   (padded_message[i + j * 4 + 2] << 8) |
                   (padded_message[i + j * 4 + 3]);
        }
        // 扩展16个字为80个字
        for (uint32_t j = 16; j < 80; j++) {
            w[j] = ROTLEFT(w[j-3] ^ w[j-8] ^ w[j-14] ^ w[j-16], 1);
        }
        // 初始化哈希值
        uint32_t a = H[0];
        uint32_t b = H[1];
        uint32_t c = H[2];
        uint32_t d = H[3];
        uint32_t e = H[4];
        // 主循环
        for (uint32_t j = 0; j < 80; j++) {
            uint32_t f, k;
            if (j < 20) {
                f = (b & c) | ((~b) & d);
                k = K[0];
            } else if (j < 40) {
                f = b ^ c ^ d;
                k = K[1];
            } else if (j < 60) {
                f = (b & c) | (b & d) | (c & d);
                k = K[2];
            } else {
                f = b ^ c ^ d;
                k = K[3];
            }
            uint32_t temp = ROTLEFT(a, 5) + f + e + k + w[j];
            e = d;
            d = c;
            c = ROTLEFT(b, 30);
            b = a;
            a = temp;
        }
        // 更新哈希值
        H[0] += a;
        H[1] += b;
        H[2] += c;
        H[3] += d;
        H[4] += e;
        // 释放内存
        delete[] w;
    }
    // 保存哈希值
    std::memcpy(digest, H, sizeof(H));
    // 释放内存
    delete[] padded_message;
}

int main() {
    uint8_t message[] = "hello world";
    uint32_t digest[5];
    sha1(message, std::strlen((const char*)message), digest);
    std::cout << std::hex << digest[0] << digest[1] << digest[2] << digest[3] << digest[4] << std::endl;
    return 0;
}

注意，这只是一个简单的示例代码，实际应用中需要考虑更多安全性和性能方面的问题。