使用C语言计算两个日期之间间隔了多少分钟的方法：





默认计算2000年之后的，否则请改一下year_afer2000 那个地方。

默认计算间隔了多少分钟，若要计算秒钟，需要对应修改一下整体。

```c
#include <stdio.h>
//#include <stdlib.h>
//#include <ctype.h>
//#include <string.h>
//#include <stdio.h>
//#include <time.h>
unsigned long cal_total_min( int year, int month, int day, int hour, int minute )
{
    unsigned long total_minutes1;
    unsigned long total_minutes2;
    unsigned long total_minutes3;
    unsigned long total_minutes4;
    unsigned long date1_minutes;
    int year_afer2000;
    int  i;
    int  month_days[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
    /* 计算日期1到日期2的总分钟数 */
    total_minutes1 = 0;
    year_afer2000 = year - 2000;                                /* 默认计算2000年之后的 */
    for ( i = 0; i < year_afer2000; i++ )
    {
        if ( (i % 4 == 0 && i % 100 != 0) || i % 400 == 0 )     /* 闰年 */
            total_minutes1 += 366 * 24 * 60;
        else
            total_minutes1 += 365 * 24 * 60;
    }
    total_minutes2 = 0;
    for ( i = 0; i < month - 1; i++ )
        if ( i == 1 )                                                           /* 2月 */
        {
            if ( (year % 4 == 0 && year % 100 != 0) || year % 400 == 0 )    /* 闰年 */
                total_minutes2 += 29 * 24 * 60;
            else
                total_minutes2 += 28 * 24 * 60;
        } else {
            total_minutes2 += month_days[i] * 24 * 60;
        }
    total_minutes3 = day * 24 * 60;
    total_minutes4 = hour * 60 + minute;
    date1_minutes = total_minutes1 + total_minutes2 + total_minutes3 + total_minutes4;
    return(date1_minutes);
}
/* 计算两个日期相差多少分钟的绝对值,考虑每个月天数和闰年 */
unsigned long cal_two_time_diff( char *time1, char *time2 )
{
    int  year1, month1, day1, hour1, minute1;
    int  year2, month2, day2, hour2, minute2;
    unsigned long date1_minutes;
    unsigned long date2_minutes;
    sscanf( time1, "%4d%2d%2d%2d%2d", &year1, &month1, &day1, &hour1, &minute1 );
    sscanf( time2, "%4d%2d%2d%2d%2d", &year2, &month2, &day2, &hour2, &minute2 );
    date1_minutes = cal_total_min( year1, month1, day1, hour1, minute1 );
    date2_minutes = cal_total_min( year2, month2, day2, hour2, minute2 );
    /* 两个日期相差的绝对分钟数 */
    if ( date1_minutes > date2_minutes )
        return(date1_minutes - date2_minutes);
    else
        return(date2_minutes - date1_minutes);
}
int main() {
    unsigned long diff_minutes = cal_two_time_diff("202312312359", "200001010000");
    printf("两个日期相差的分钟数为:%lu\n", diff_minutes);
    return 0;
}
```

使用C语言计算两个日期之间间隔了多少分钟的程序

书籍下载：[程序员的自我修养：链接、装载与库.pdf - 经典技术书籍](https://awesome-programming-books.github.io/others/%E7%A8%8B%E5%BA%8F%E5%91%98%E7%9A%84%E8%87%AA%E6%88%91%E4%BF%AE%E5%85%BB%EF%BC%9A%E9%93%BE%E6%8E%A5%E3%80%81%E8%A3%85%E8%BD%BD%E4%B8%8E%E5%BA%93.pdf)






# GCC编译过程

- 预编译 prepressing，将cpp、hpp转为.i 结尾的文件；

- 编译 compilation

- 汇编 assembly

- 链接 linking

![在这里插入图片描述](/static/img/images/04601.png)

# 目标文件

![在这里插入图片描述](/static/img/images/04602.png)

![在这里插入图片描述](/static/img/images/04603.png)

【C++】GCC编译过程与目标文件类别

一开始想使用nmslib的，conan中引用后发现nmslib的C++示例代码太难写了，改为使用flann去实现，opencv中已纳入了flann，使用起来更方便了。






下面这段代码实现了使用 KD-Tree 算法进行 K 近邻搜索的函数 knn_nmslib，其中调用了 normalizeFeatures 函数用于对特征向量进行标准化处理。最终目的是计算每个特征的k近邻是谁，余弦距离是多少。

具体来说，该函数输入一个特征向量集合 feats，输出每个特征向量的前 k 个最近邻索引和对应的距离，存储在一个 vector<vector<int>> 和一个 vector<vector<float>> 中，分别表示索引和距离。

在函数中，首先复制一份输入特征向量 feats 到 feats_copy，然后对 feats_copy 中的每个特征向量进行标准化处理，即将其 L2 范数归一化为 1。标准化后，将 feats_copy 转换为一个 cv::Mat 对象 features，作为 K 近邻搜索的数据集。

接着，使用 cv::flann::Index 创建一个 KD-Tree 索引，使用欧几里得距离作为距离度量。然后，将 features 作为查询数据进行 K 近邻搜索，返回每个查询数据的前 k 个最近邻的索引和距离，存储在 cv::Mat 对象 indices 和 dists 中。

最后，对于每个查询数据，将其前 k 个最近邻的索引和距离存储到 neighbours 中，同时计算每个最近邻之间的余弦距离，并保存到 distance22 中，方便后续的计算。函数最后释放 KD-Tree 索引的内存。

```c
#include <opencv2/opencv.hpp>
#include <opencv2/flann.hpp>
#include <utility>
float findCosineSimilarity(const std::vector<float>& source_representation,
                           const std::vector<float>& test_representation) {
    return 1.0f - findCosineDistance(source_representation, test_representation);
}
float findCosineDistance(const std::vector<float>& source_representation,
                         const std::vector<float>& test_representation) {
    cv::Mat source(source_representation);
    cv::Mat test(test_representation);
    double dist = 1.0 - source.dot(test) / (cv::norm(source) * cv::norm(test, cv::NORM_L2) + 0.000001);
    return static_cast<float>(dist);
}
void normalizeFeatures(std::vector<std::vector<float>>& features) {
    for (auto& feature : features) {
        cv::Mat mat(feature);
        double norm = cv::norm(mat, cv::NORM_L2);
        mat = mat / norm;
        for (int i = 0; i < mat.cols; ++i) {
            feature[i] = mat.at<float>(0, i);
        }
    }
}
void knn_nmslib(const std::vector<std::vector<float>>& feats,
                std::vector<std::pair<std::vector<int>, std::vector<float>>>& neighbours,
                int k) {
    // 复制一份feats出来
    std::vector<std::vector<float>> feats_copy(feats);
    // 标准化
    normalizeFeatures(feats_copy);
    cv::Mat features(feats_copy.size(), feats_copy[0].size(), CV_32F);
    features.forEach<float>(
        [&](float& pixel, const int* position) -> void { pixel = feats_copy[position[0]][position[1]]; });
    // 设置搜索算法为KD-Tree，使用欧几里得距离
    cv::flann::Index flannIndex(features, cv::flann::KDTreeIndexParams(4), cvflann::FLANN_DIST_EUCLIDEAN);
    // 设置查询数据
    cv::Mat query = features;
    // 进行k近邻搜索
    cv::Mat indices(query.rows, k, CV_32S);
    cv::Mat dists(query.rows, k, CV_32F);
    flannIndex.knnSearch(query, indices, dists, k, cv::flann::SearchParams(256));
    std::map<std::pair<int, int>, float> distance22;
    float dist_tmp;
    for (int i = 0; i < query.rows; i++) {
        std::vector<int> index;
        std::vector<float> dist;
        for (int j = 0; j < k; j++) {
            index.push_back(indices.at<int>(i, j));
            // 查询distance22中是否存在（i,j）
            if (distance22.find(std::make_pair(i, indices.at<int>(i, j))) == distance22.end()) {
                dist_tmp = findCosineDistance(feats[i], feats[indices.at<int>(i, j)]);
                distance22[std::make_pair(i, indices.at<int>(i, j))] = dist_tmp;
                distance22[std::make_pair(indices.at<int>(i, j), i)] = dist_tmp;
            } else {
                dist_tmp = distance22[std::make_pair(i, indices.at<int>(i, j))];
            }
            dist.push_back(dist_tmp);  // 距离保存
        }
        neighbours.push_back(std::make_pair(index, dist));
    }
    //释放内存
    flannIndex.release();
}
```

使用opencv::flann C++进行k近邻搜索，余弦距离

conan openssl:





[https://conan.io/center/openssl](https://conan.io/center/openssl)

ubuntu需要安装：

```shell
 sudo apt-get install libvulkan-dev
```

示例代码：
```c
#include <openssl/md5.h>
std::string md5sum(const std::string& str) {
    std::string md5;
    MD5_CTX ctx;
    MD5_Init(&ctx);
    MD5_Update(&ctx, str.c_str(), str.size());
    unsigned char digest[MD5_DIGEST_LENGTH];
    MD5_Final(digest, &ctx);
    char hex[35];
    memset(hex, 0, sizeof(hex));
    for (int i = 0; i < MD5_DIGEST_LENGTH; ++i) {
        sprintf(hex + i * 2, "%02x", digest[i]);
    }
    md5 = std::string(hex);
    return md5;
}
```

C++ openssl 计算字符串的md5数值

conan cpp-httplib/0.11.3:





[https://conan.io/center/cpp-httplib](https://conan.io/center/cpp-httplib)


如果请求“https://fanyi.baidu.com/api/trans?appid=12345&from=auto&q=text&salt=123214&sign=sdasfasf213&to=auto”的结果：

```c
#include "httplib.h"
int main() {
  httplib::Client client("fanyi.baidu.com");
  httplib::Params params;
  params.emplace("appid", "12345");
  params.emplace("from", "auto");
  params.emplace("q", "text");
  params.emplace("salt", "123214");
  params.emplace("sign", "sdasfasf213");
  params.emplace("to", "auto");
  auto res = client.Get("/api/trans", params);
  if (res && res->status == 200) {
    // 处理响应结果
    std::cout << res->body << std::endl;
  }
  return 0;
}
```

C++ httplib Get请求代码

我是一个专注技术分享的博主,尤其爱搞深度学习和单片机电子。你现在看到的是我的个人博客网站。