[C言語] bsearch_s関数の使い方 – セキュアなバイナリサーチ

void *bsearch_s(const void *key, const void *base, rsize_t nmemb, rsize_t size, int (*compar)(const void *k, const void *e, void *context), void *context);

void* bsearch_s(const void* key, const void* base, size_t nmemb, size_t size, 
                int (*compar)(const void*, const void*, void*), void* context);

int compar(void* context, const void* a, const void* b);

#include <stdio.h>
#include <stdlib.h>

// 比較関数のシグネチャを修正
int compar(void* context, const void* a, const void* b) {
    // aとbを整数として比較
    return (*(int*)a - *(int*)b);
}

int main() {
    int array[] = {1, 3, 5, 7, 9};
    int key = 5; // 検索する要素
    size_t nmemb = sizeof(array) / sizeof(array[0]);
    size_t size = sizeof(int);
    void* result;

    // bsearch_s関数を使用して検索
    result = bsearch_s(&key, array, nmemb, size, compar, NULL);
    if (result != NULL) {
        printf("要素 %d が見つかりました。\n", *(int*)result);
    } else {
        printf("要素 %d は見つかりませんでした。\n", key);
    }
    return 0;
}

要素 5 が見つかりました。

int compar(void* context, const void* a, const void* b) {
    // aとbを適切にキャストして比較
    return (*(int*)a - *(int*)b);
}

#include <stdio.h>
typedef struct {
    int threshold; // 比較の閾値
} Context;
int compar_with_context(void* context, const void* a, const void* b) {
    Context* ctx = (Context*)context;
    int valueA = *(int*)a;
    int valueB = *(int*)b;
    // 閾値を考慮して比較
    if (valueA < ctx->threshold && valueB < ctx->threshold) {
        return valueA - valueB; // 通常の比較
    }
    return valueA - valueB; // ここでは単純な比較を行う
}

#include <stdio.h>
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int compar_thread_safe(void* context, const void* a, const void* b) {
    pthread_mutex_lock(&mutex); // ミューテックスをロック
    int result = (*(int*)a - *(int*)b);
    pthread_mutex_unlock(&mutex); // ミューテックスをアンロック
    return result;
}

#include <stdio.h>
int compar_with_error_check(void* context, const void* a, const void* b) {
    if (a == NULL || b == NULL) {
        // NULLポインタが渡された場合のエラーハンドリング
        fprintf(stderr, "エラー: NULLポインタが渡されました。\n");
        return 0; // エラー時は0を返す
    }
    return (*(int*)a - *(int*)b);
}

#include <stdio.h>
#include <stdlib.h>
typedef struct {
    int id;
    char name[20];
} Person;
int compar_person(void* context, const void* a, const void* b) {
    return ((Person*)a)->id - ((Person*)b)->id;
}
int main() {
    Person people[] = {
        {1, "Alice"},
        {2, "Bob"},
        {3, "Charlie"}
    };
    Person key = {2, ""}; // 検索するIDを持つ構造体
    size_t nmemb = sizeof(people) / sizeof(people[0]);
    size_t size = sizeof(Person);
    void* result;
    result = bsearch_s(&key, people, nmemb, size, compar_person, NULL);
    if (result != NULL) {
        printf("見つかった: %s\n", ((Person*)result)->name);
    } else {
        printf("見つかりませんでした。\n");
    }
    return 0;
}

見つかった: Bob

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
typedef struct {
    int* array;
    int key;
    size_t nmemb;
    void* result;
} ThreadData;
int compar_int(void* context, const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}
void* search_in_thread(void* arg) {
    ThreadData* data = (ThreadData*)arg;
    data->result = bsearch_s(&data->key, data->array, data->nmemb, sizeof(int), compar_int, NULL);
    return NULL;
}
int main() {
    int array[] = {1, 3, 5, 7, 9};
    ThreadData data = {array, 5, sizeof(array) / sizeof(array[0]), NULL};
    pthread_t thread;
    pthread_create(&thread, NULL, search_in_thread, &data);
    pthread_join(thread, NULL);
    if (data.result != NULL) {
        printf("要素 %d が見つかりました。\n", *(int*)data.result);
    } else {
        printf("要素 %d は見つかりませんでした。\n", data.key);
    }
    return 0;
}

要素 5 が見つかりました。

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int min;
    int max;
} Range;

int compar_range(void* context, const void* a, const void* b) {
    Range* range = (Range*)context;
    int element = *(int*)b;
    if (element < range->min) return -1;
    if (element > range->max) return 1;
    return 0;
}

int main() {
    int array[] = {1, 3, 5, 7, 9};
    Range range = {4, 8}; // 検索範囲
    size_t nmemb = sizeof(array) / sizeof(array[0]);
    void* result;

    // bsearch_sを使用して範囲内の最初の値を検索
    result = bsearch_s(&range.min, array, nmemb, sizeof(int), compar_range, &range);
    if (result != NULL) {
        printf("範囲内の要素 %d が見つかりました。\n", *(int*)result);
    } else {
        printf("範囲内の要素は見つかりませんでした。\n");
    }

    return 0;
}

範囲内の要素 5 が見つかりました。

#include <stdio.h>
#include <stdlib.h>
int compar_large_data(void* context, const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}
int main() {
    size_t nmemb = 1000000;
    int* array = malloc(nmemb * sizeof(int));
    // 配列を初期化
    for (size_t i = 0; i < nmemb; i++) {
        array[i] = (int)i;
    }
    int key = 999999; // 検索する要素
    void* result;
    // bsearch_sを使用して検索
    result = bsearch_s(&key, array, nmemb, sizeof(int), compar_large_data, NULL);
    if (result != NULL) {
        printf("要素 %d が見つかりました。\n", *(int*)result);
    } else {
        printf("要素 %d は見つかりませんでした。\n", key);
    }
    free(array);
    return 0;
}

要素 999999 が見つかりました。

#include <stdio.h>
#include <stdlib.h>
int compar(void* context, const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}
int main() {
    int array[] = {3, 1, 2}; // ソートされていない配列
    int key = 2;
    size_t nmemb = sizeof(array) / sizeof(array[0]);
    void* result;
    // ソートされていない配列での検索
    result = bsearch_s(&key, array, nmemb, sizeof(int), compar, NULL);
    if (result != NULL) {
        printf("要素 %d が見つかりました。\n", *(int*)result);
    } else {
        printf("要素 %d は見つかりませんでした。\n", key);
    }
    return 0;
}

int faulty_compar(void* context, const void* a, const void* b) {
    // 不正な比較ロジック
    return (*(int*)b - *(int*)a; // 逆に比較している
}

if (array == NULL) {
    fprintf(stderr, "エラー: 配列がNULLです。\n");
    return -1;
}

Context* ctx = (Context*)context;
if (ctx == NULL) {
    fprintf(stderr, "エラー: コンテキストがNULLです。\n");
    return 0; // エラー処理
}