c语言中如何存储大量数据库

在C语言中存储大量数据库的方法有：使用文件系统、使用内存数据库、集成外部数据库库、使用B树或哈希表。其中，使用文件系统是一种常见的方法，通过将数据存储在文本文件或二进制文件中，可以实现较大的存储容量。下面将详细讨论如何在C语言中使用文件系统存储大量数据。

一、使用文件系统

1、文本文件

文本文件是最简单的存储方式。可以使用标准库函数如 fopen、fprintf 和 fscanf 来读写数据。文本文件的优点是简单易用，缺点是效率较低，且不适合存储复杂数据结构。

#include <stdio.h>
void save_data() {
    FILE *file = fopen("data.txt", "w");
    if (file == NULL) {
        perror("Failed to open file");
        return;
    }
    fprintf(file, "ID,Name,Agen");
    fprintf(file, "1,John Doe,30n");
    fprintf(file, "2,Jane Smith,25n");
    fclose(file);
}
void load_data() {
    FILE *file = fopen("data.txt", "r");
    if (file == NULL) {
        perror("Failed to open file");
        return;
    }
    char buffer[256];
    while (fgets(buffer, sizeof(buffer), file)) {
        printf("%s", buffer);
    }
    fclose(file);
}
int main() {
    save_data();
    load_data();
    return 0;
}

2、二进制文件

二进制文件相比文本文件更高效，适合存储复杂数据结构。可以使用 fwrite 和 fread 函数来操作二进制文件。

#include <stdio.h>
typedef struct {
    int id;
    char name[50];
    int age;
} Person;
void save_data() {
    FILE *file = fopen("data.bin", "wb");
    if (file == NULL) {
        perror("Failed to open file");
        return;
    }
    Person persons[] = {
        {1, "John Doe", 30},
        {2, "Jane Smith", 25}
    };
    fwrite(persons, sizeof(Person), 2, file);
    fclose(file);
}
void load_data() {
    FILE *file = fopen("data.bin", "rb");
    if (file == NULL) {
        perror("Failed to open file");
        return;
    }
    Person persons[2];
    fread(persons, sizeof(Person), 2, file);
    fclose(file);
    for (int i = 0; i < 2; i++) {
        printf("ID: %d, Name: %s, Age: %dn", persons[i].id, persons[i].name, persons[i].age);
    }
}
int main() {
    save_data();
    load_data();
    return 0;
}

二、使用内存数据库

内存数据库如 SQLite 是一种轻量级的嵌入式数据库，支持 SQL 查询，适合在 C 语言项目中使用。SQLite 提供了一个 C 语言 API，可以很方便地进行数据操作。

#include <stdio.h>
#include <sqlite3.h>
void execute_query(sqlite3 *db, const char *sql) {
    char *errmsg = NULL;
    int rc = sqlite3_exec(db, sql, 0, 0, &errmsg);
    if (rc != SQLITE_OK) {
        fprintf(stderr, "SQL error: %sn", errmsg);
        sqlite3_free(errmsg);
    }
}
int main() {
    sqlite3 *db;
    int rc = sqlite3_open("test.db", &db);
    if (rc) {
        fprintf(stderr, "Can't open database: %sn", sqlite3_errmsg(db));
        return 1;
    }
    const char *create_table_sql = "CREATE TABLE IF NOT EXISTS Person(ID INT, Name TEXT, Age INT);";
    execute_query(db, create_table_sql);
    const char *insert_data_sql = "INSERT INTO Person (ID, Name, Age) VALUES (1, 'John Doe', 30);"
                                  "INSERT INTO Person (ID, Name, Age) VALUES (2, 'Jane Smith', 25);";
    execute_query(db, insert_data_sql);
    const char *select_data_sql = "SELECT * FROM Person;";
    sqlite3_stmt *stmt;
    rc = sqlite3_prepare_v2(db, select_data_sql, -1, &stmt, 0);
    if (rc != SQLITE_OK) {
        fprintf(stderr, "Failed to fetch data: %sn", sqlite3_errmsg(db));
        return 1;
    }
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        int id = sqlite3_column_int(stmt, 0);
        const unsigned char *name = sqlite3_column_text(stmt, 1);
        int age = sqlite3_column_int(stmt, 2);
        printf("ID: %d, Name: %s, Age: %dn", id, name, age);
    }
    sqlite3_finalize(stmt);
    sqlite3_close(db);
    return 0;
}

三、集成外部数据库库

有些项目需要与大型数据库系统如 MySQL 或 PostgreSQL 集成。可以使用相应的 C API 库来进行数据库操作。例如，MySQL 提供了一个 C API，可以在 C 语言项目中使用。

#include <mysql/mysql.h>
#include <stdio.h>
#include <stdlib.h>
void finish_with_error(MYSQL *con) {
    fprintf(stderr, "%sn", mysql_error(con));
    mysql_close(con);
    exit(1);
}
int main() {
    MYSQL *con = mysql_init(NULL);
    if (con == NULL) {
        fprintf(stderr, "mysql_init() failedn");
        exit(1);
    }
    if (mysql_real_connect(con, "localhost", "user", "password", "testdb", 0, NULL, 0) == NULL) {
        finish_with_error(con);
    }
    if (mysql_query(con, "CREATE TABLE IF NOT EXISTS Person(ID INT PRIMARY KEY, Name TEXT, Age INT)")) {
        finish_with_error(con);
    }
    if (mysql_query(con, "INSERT INTO Person (ID, Name, Age) VALUES(1, 'John Doe', 30)")) {
        finish_with_error(con);
    }
    if (mysql_query(con, "INSERT INTO Person (ID, Name, Age) VALUES(2, 'Jane Smith', 25)")) {
        finish_with_error(con);
    }
    if (mysql_query(con, "SELECT * FROM Person")) {
        finish_with_error(con);
    }
    MYSQL_RES *result = mysql_store_result(con);
    if (result == NULL) {
        finish_with_error(con);
    }
    int num_fields = mysql_num_fields(result);
    MYSQL_ROW row;
    while ((row = mysql_fetch_row(result))) {
        for (int i = 0; i < num_fields; i++) {
            printf("%s ", row[i] ? row[i] : "NULL");
        }
        printf("n");
    }
    mysql_free_result(result);
    mysql_close(con);
    return 0;
}

四、使用B树或哈希表

如果需要在内存中存储大量数据，可以使用数据结构如 B 树或哈希表。B 树适合存储有序数据，哈希表适合快速查找。

1、B树

B 树是一种平衡树，具有良好的查找、插入和删除性能。可以在 C 语言中实现 B 树来存储大量数据。

#include <stdio.h>
#include <stdlib.h>
#define T 2
typedef struct BTreeNode {
    int *keys;
    int t;
    struct BTreeNode C;
    int n;
    int leaf;
} BTreeNode;
BTreeNode* createNode(int t, int leaf) {
    BTreeNode *node = (BTreeNode *)malloc(sizeof(BTreeNode));
    node->t = t;
    node->leaf = leaf;
    node->keys = (int *)malloc((2*t-1) * sizeof(int));
    node->C = (BTreeNode )malloc(2*t * sizeof(BTreeNode *));
    node->n = 0;
    return node;
}
void traverse(BTreeNode *root) {
    int i;
    for (i = 0; i < root->n; i++) {
        if (!root->leaf) {
            traverse(root->C[i]);
        }
        printf(" %d", root->keys[i]);
    }
    if (!root->leaf) {
        traverse(root->C[i]);
    }
}
BTreeNode* search(BTreeNode *root, int k) {
    int i = 0;
    while (i < root->n && k > root->keys[i]) {
        i++;
    }
    if (i < root->n && root->keys[i] == k) {
        return root;
    }
    if (root->leaf) {
        return NULL;
    }
    return search(root->C[i], k);
}
void insertNonFull(BTreeNode *x, int k) {
    int i = x->n - 1;
    if (x->leaf) {
        while (i >= 0 && x->keys[i] > k) {
            x->keys[i+1] = x->keys[i];
            i--;
        }
        x->keys[i+1] = k;
        x->n++;
    } else {
        while (i >= 0 && x->keys[i] > k) {
            i--;
        }
        if (x->C[i+1]->n == 2*x->t-1) {
            // Split child
        } else {
            insertNonFull(x->C[i+1], k);
        }
    }
}
void insert(BTreeNode root, int t, int k) {
    if (*root == NULL) {
        *root = createNode(t, 1);
        (*root)->keys[0] = k;
        (*root)->n = 1;
    } else {
        if ((*root)->n == 2*t-1) {
            // Split root
        } else {
            insertNonFull(*root, k);
        }
    }
}
int main() {
    BTreeNode *root = NULL;
    insert(&root, T, 10);
    insert(&root, T, 20);
    insert(&root, T, 5);
    insert(&root, T, 6);
    insert(&root, T, 12);
    insert(&root, T, 30);
    insert(&root, T, 7);
    insert(&root, T, 17);
    printf("Traversal of the B-tree is: ");
    traverse(root);
    printf("n");
    return 0;
}

2、哈希表

哈希表提供了快速的查找、插入和删除操作。可以使用链地址法或开放地址法来处理哈希冲突。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TABLE_SIZE 100
typedef struct Entry {
    int key;
    char value[50];
    struct Entry *next;
} Entry;
Entry* table[TABLE_SIZE];
unsigned int hash(int key) {
    return key % TABLE_SIZE;
}
void insert(int key, const char *value) {
    unsigned int index = hash(key);
    Entry *new_entry = (Entry *)malloc(sizeof(Entry));
    new_entry->key = key;
    strcpy(new_entry->value, value);
    new_entry->next = table[index];
    table[index] = new_entry;
}
char* search(int key) {
    unsigned int index = hash(key);
    Entry *entry = table[index];
    while (entry != NULL) {
        if (entry->key == key) {
            return entry->value;
        }
        entry = entry->next;
    }
    return NULL;
}
int main() {
    insert(1, "John Doe");
    insert(2, "Jane Smith");
    insert(102, "Alice Johnson");
    char *value = search(2);
    if (value) {
        printf("Found: %sn", value);
    } else {
        printf("Not foundn");
    }
    value = search(102);
    if (value) {
        printf("Found: %sn", value);
    } else {
        printf("Not foundn");
    }
    return 0;
}

五、总结

在C语言中存储大量数据库可以通过多种方法实现，包括使用文件系统、内存数据库、集成外部数据库库以及使用数据结构如B树和哈希表。每种方法都有其优缺点，选择合适的方法需要根据具体的需求和环境来决定。无论选择哪种方法，关键在于理解每种技术的工作原理，并根据实际情况进行优化和调整。