C Mysql API連接Mysql

最近都在查看MYsql C API文檔，也遇到了很多問題，下面來簡單的做一個總結。

 

mysql多線程問題

• mysql多線程處理不好，經常會發生coredump，見使用Mysql出core一文。

單線程

• 一般情況下，單線程連接mysql代碼如下：

/*
        single_thread_mysql_client.cpp
    */
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <mysql/mysql.h>
    #include <pthread.h>
    #include <unistd.h>

    #define DBHOST      "localhost"
    #define DBUSER      "pca"
    #define DBPASS      "pca"
    #define DBPORT      3306
    #define DBNAME      "dxponline"
    #define DBSOCK      NULL //"/var/lib/mysql/mysql.sock"
    #define DBPCNT      0

    int main()
    {
        MYSQL_RES *result;
        MYSQL_ROW row;
        MYSQL_FIELD *field;
        unsigned int num_fields;
        unsigned int i;
        const char *pStatement = "SHOW TABLES";
        mysql_library_init(0, NULL, NULL);
        MYSQL *mysql = mysql_init(NULL);
        unsigned int timeout = 3000;
        mysql_options(mysql, MYSQL_OPT_CONNECT_TIMEOUT, &timeout);

        if (mysql_real_connect(mysql, DBHOST, DBUSER, DBPASS, DBNAME, DBPORT, DBSOCK, DBPCNT) == NULL)
        {
            printf("connect failed: %s\n", mysql_error(mysql));
            mysql_close(mysql);
            mysql_library_end();
            return 0;
        }

        printf("connect succssfully\n");

        if (0 != mysql_real_query(mysql, pStatement, strlen(pStatement)))
        {
            printf("query failed: %s\n", mysql_error(mysql));
            mysql_close(mysql);
            mysql_library_end();
            return 0;
        }

        result = mysql_store_result(mysql);

        if (result == NULL)
        {
            printf("fetch result failed: %s\n", mysql_error(mysql));
            mysql_close(mysql);
            mysql_library_end();
            return 0;
        }

        num_fields = mysql_num_fields(result);
        printf("numbers of result: %d\n", num_fields);

        while (NULL != (field = mysql_fetch_field(result)))
        {
            printf("field name: %s\n", field->name);
        }

        while (NULL != (row = mysql_fetch_row(result)))
        {
            unsigned long *lengths;
            lengths = mysql_fetch_lengths(result);

            for (i = 0; i < num_fields; i++)
            {
                printf("{%.*s} ", (int) lengths[i], row[i] ? row[i] : "NULL");
            }

            printf("\n");
        }

        mysql_free_result(result);
        mysql_close(mysql);
        mysql_library_end();
        return 0;
    }

 

• 執行

  make single_thread_mysql_client LDFLAGS="-g -O2 -L/usr/lib64/mysql -lmysqlclient -lpthread -lz -lm -lssl -lcrypto -ldl"

  即可獲得對應單線程二進制。

多線程

• 多線程主要需要注意以下幾點
  • mysql_library_init 和 mysql_library_end 需要放入主線程；
  • 連接句柄需要多個才能加快並發，而連接句柄由 mysql_init 生成，而 mysql_init跟隨機函數 rand 有點相似，第一次需要初始化后才能線程安全，所以需要使用mysql_thread_init 和 mysql_thread_end 兩個函數來保證線程安全；
• 一般多線程連接mysql代碼如下

/*
        muti_thread_mysql_client.cpp
    */
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <mysql/mysql.h>
    #include <pthread.h>
    #include <unistd.h>

    #define THREAD_NUM  4
    #define DBHOST      "localhost"
    #define DBUSER      "pca"
    #define DBPASS      "pca"
    #define DBPORT      3306
    #define DBNAME      "dxponline"
    #define DBSOCK      NULL //"/var/lib/mysql/mysql.sock"
    #define DBPCNT      0

    typedef struct ThreadArgsST
    {
        int id;
        pthread_t *thread_id;
    } ThreadArgs;

    void *func(void *arg)
    {
        ThreadArgs *args = (ThreadArgs *)arg;
        MYSQL_RES *result;
        MYSQL_ROW row;
        MYSQL_FIELD *field;
        unsigned int num_fields;
        unsigned int i;
        unsigned int timeout = 3000;
        const char *pStatement = "SHOW TABLES";
        mysql_thread_init();
        MYSQL *mysql = mysql_init(NULL);

        if (mysql == NULL)
        {
            printf("[%ld][%d]mysql init failed: %s\n", *args->thread_id, args->id, mysql_error(mysql));
            return (void *)0;
        }

        mysql_options(mysql, MYSQL_OPT_CONNECT_TIMEOUT, &timeout);

        if (mysql_real_connect(mysql, DBHOST, DBUSER, DBPASS, DBNAME, DBPORT, DBSOCK, DBPCNT) == NULL)
        {
            printf("[%ld][%d]connect failed: %s\n", *args->thread_id, args->id, mysql_error(mysql));
            mysql_close(mysql);
            mysql_thread_end();
            return (void *)0;
        }

        printf("[%ld][%d]connect succssfully\n", *args->thread_id, args->id);

        if (0 != mysql_real_query(mysql, pStatement, strlen(pStatement)))
        {
            printf("[%ld][%d]query failed: %s\n", *args->thread_id, args->id, mysql_error(mysql));
            mysql_close(mysql);
            mysql_thread_end();
            return (void *)0;
        }

        result = mysql_store_result(mysql);

        if (result == NULL)
        {
            printf("[%ld][%d]fetch result failed: %s\n", *args->thread_id, args->id, mysql_error(mysql));
            mysql_close(mysql);
            mysql_thread_end();
            return (void *)0;
        }

        num_fields = mysql_num_fields(result);
        printf("[%ld][%d]numbers of result: %d\n", *args->thread_id, args->id, num_fields);

        while (NULL != (field = mysql_fetch_field(result)))
        {
            printf("[%ld][%d]field name: %s\n", *args->thread_id, args->id, field->name);
        }

        while (NULL != (row = mysql_fetch_row(result)))
        {
            unsigned long *lengths;
            lengths = mysql_fetch_lengths(result);

            for (i = 0; i < num_fields; i++)
            {
                printf("[%ld][%d]{%.*s} ", *args->thread_id, args->id, (int) lengths[i], row[i] ? row[i] : "NULL");
            }

            printf("\n");
        }

        mysql_free_result(result);
        mysql_close(mysql);
        mysql_thread_end();
        return (void *)0;
    }

    int main(int argc, char *argv[])
    {
        int thread_num;

        if (argc == 2)
        {
            thread_num = atoi(argv[1]);
        }
        else
        {
            thread_num = THREAD_NUM;
        }

        mysql_library_init(0, NULL, NULL);
        printf("argc: %d and thread_num: %d\n", argc, thread_num);

        do
        {
            pthread_t *pTh = new pthread_t[thread_num];
            ThreadArgs *pArgs = new ThreadArgs[thread_num];
            int i;

            for (i = 0; i < thread_num; i ++)
            {
                pArgs[i].id = i;
                pArgs[i].thread_id = &pTh[i];

                if (0 != pthread_create(&pTh[i], NULL, func, &pArgs[i]))
                {
                    printf("pthread_create failed\n");
                    continue;
                }
            }

            for (i = 0; i < thread_num; i ++)
            {
                pthread_join(pTh[i], NULL);
            }

            delete[] pTh;
            delete[] pArgs;
        }
        while (0);

        mysql_library_end();
        return 0;
    }

 

• 執行

  make muti_thread_mysql_client LDFLAGS="-g -O2 -L/usr/lib64/mysql -lmysqlclient -lpthread -lz -lm -lssl -lcrypto -ldl"

  即可獲得對應單線程二進制。

• 連接數與連接句柄是一一對應關系，故一般使用長連接，所以需要連接池，所以上面的代碼可以有優化的空間，代碼見：

/*
        muti_thread_mysql_client_pool.cpp
    */
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <mysql/mysql.h>
    #include <pthread.h>
    #include <unistd.h>
    #include <queue>
    #include <string>

    #define THREAD_NUM  4
    #define DBHOST      "localhost"
    #define DBUSER      "pca"
    #define DBPASS      "pca"
    #define DBPORT      3306
    #define DBNAME      "dxponline"
    #define DBSOCK      NULL //"/var/lib/mysql/mysql.sock"
    #define DBPCNT      0

    using namespace std;

    class CBlockQueue;
    typedef struct ThreadArgsST
    {
        int id;
        pthread_t *thread_id;
        CBlockQueue *pQueue;
    } ThreadArgs;

    class CMutex
    {
    public:
        CMutex()
        {
            pthread_mutex_init(&_mutex, NULL);
        }
        ~CMutex()
        {
            pthread_mutex_destroy(&_mutex);
        }

        int32_t lock()
        {
            return pthread_mutex_lock(&_mutex);
        }

        int32_t unlock()
        {
            return pthread_mutex_unlock(&_mutex);
        }

        int32_t trylock()
        {
            return pthread_mutex_trylock(&_mutex);
        }

    private:
        pthread_mutex_t _mutex;
    };

    class CGlobalFunction
    {
    public:
        static MYSQL *connect()
        {
            unsigned int timeout = 3000;
            mysql_thread_init();
            MYSQL *mysql = mysql_init(NULL);

            if (mysql == NULL)
            {
                printf("mysql init failed: %s\n", mysql_error(mysql));
                return NULL;
            }

            mysql_options(mysql, MYSQL_OPT_CONNECT_TIMEOUT, &timeout);

            if (mysql_real_connect(mysql, DBHOST, DBUSER, DBPASS, DBNAME, DBPORT, DBSOCK, DBPCNT) == NULL)
            {
                printf("connect failed: %s\n", mysql_error(mysql));
                mysql_close(mysql);
                mysql_thread_end();
                return NULL;
            }

            printf("connect succssfully\n");
            return mysql;
        }
    };

    class CBlockQueue : public CMutex
    {
    public:
        CBlockQueue() : _size(512)
        {
        }
        ~CBlockQueue()
        {
        }
        void set_size(int size)
        {
            _size = size;
        }
        int size()
        {
            this->lock();
            int size = q.size();
            this->unlock();
            return size;
        }
        bool push(void *m)
        {
            this->lock();
            // TODO
            /*
            if (q.size() > _size)
            {
                this->unlock();
                fprintf(stderr, "[QUEUE_IS_FULL]queue size over limit from push: %d\n", _size);
                return false;
            }
            */
            q.push(m);
            this->unlock();
            return true;
        }

        void *pop()
        {
            this->lock();

            if (q.empty())
            {
                this->unlock();
                fprintf(stderr, "[QUEUE_IS_EMPTY]queue is no item from pop");
                return NULL;
            }

            void *m = q.front();
            q.pop();
            this->unlock();
            return m;
        }

    private:
        queue q;
        int _size;
    };

    void *func(void *arg)
    {
        ThreadArgs *args = (ThreadArgs *)arg;
        MYSQL_RES *result;
        MYSQL_ROW row;
        MYSQL_FIELD *field;
        bool pushed = true;
        unsigned int num_fields;
        unsigned int i;
        const char *pStatement = "SHOW TABLES";
        MYSQL *db = (MYSQL *)args->pQueue->pop();

        if (db == NULL)
        {
            db = CGlobalFunction::connect();

            if (db == NULL)
            {
                printf("[%ld][%d]mysql connect failed\n", *args->thread_id, args->id);
                return (void *)0;
            }
        }

        if (0 != mysql_real_query(db, pStatement, strlen(pStatement)))
        {
            printf("[%ld][%d]query failed: %s\n", *args->thread_id, args->id, mysql_error(db));
            args->pQueue->push(db);
            return (void *)0;
        }

        result = mysql_store_result(db);

        if (result == NULL)
        {
            printf("[%ld][%d]fetch result failed: %s\n", *args->thread_id, args->id, mysql_error(db));
            args->pQueue->push(db);
            return (void *)0;
        }

        num_fields = mysql_num_fields(result);
        printf("[%ld][%d]numbers of result: %d\n", *args->thread_id, args->id, num_fields);

        while (NULL != (field = mysql_fetch_field(result)))
        {
            printf("[%ld][%d]field name: %s\n", *args->thread_id, args->id, field->name);
        }

        while (NULL != (row = mysql_fetch_row(result)))
        {
            unsigned long *lengths;
            lengths = mysql_fetch_lengths(result);

            for (i = 0; i < num_fields; i++)
            {
                printf("[%ld][%d]{%.*s} ", *args->thread_id, args->id, (int) lengths[i], row[i] ? row[i] : "NULL");
            }

            printf("\n");
        }

        mysql_free_result(result);
        args->pQueue->push(db);
        return (void *)0;
    }

    int main(int argc, char *argv[])
    {
        CBlockQueue queue;
        int thread_num;

        if (argc == 2)
        {
            thread_num = atoi(argv[1]);
        }
        else
        {
            thread_num = THREAD_NUM;
        }

        mysql_library_init(0, NULL, NULL);
        printf("argc: %d and thread_num: %d\n", argc, thread_num);

        do
        {
            int i;  
            pthread_t *pTh = new pthread_t[thread_num];
            ThreadArgs *pArgs = new ThreadArgs[thread_num];

            for (i = 0; i < thread_num; i ++)
            {
                pArgs[i].id = i;
                pArgs[i].thread_id = &pTh[i];
                pArgs[i].pQueue = &queue;

                if (0 != pthread_create(&pTh[i], NULL, func, &pArgs[i]))
                {
                    printf("pthread_create failed\n");
                    continue;
                }
            }

            for (i = 0; i < thread_num; i ++)
            {
                pthread_join(pTh[i], NULL);
            }

            delete[] pTh;
            delete[] pArgs;
            int qsize = queue.size();

            for (i = 0; i < qsize; i ++)
            {
                MYSQL *db = (MYSQL *)queue.pop();

                if (NULL != db)
                {
                    mysql_close(db);
                    mysql_thread_end();
                }
            }
        }
        while (0);

        mysql_library_end();
        return 0;
    }

 

• 執行

  make muti_thread_mysql_client_pool LDFLAGS="-g -O2 -L/usr/lib64/mysql -lmysqlclient -lpthread -lz -lm -lssl -lcrypto -ldl"

  即可獲得對應單線程二進制。

• 上述代碼就是利用隊列來保持mysql連接，達到優化連接數。

總結

• mysql連接與多線程處理不好，可能會造成很多問題，如

  • *MySQL Connection failed (#2058): This handle is already connected. Use a separate handle for each connection.*
  • Error in my_thread_global_end(): 1 threads didn't exit
  • 甚至出現coredump

• 關於多線程連接mysql優化的思想，其實可以擴展到其他連接，如HTTP、Socket等連接中；

 

測試多線程連接Mysql：

int main()  
{  
    mysql_library_init(0,NULL,NULL);  
    pthread_t producer;  
    pthread_t consumer_1;  
    pthread_t consumer_2;  
//produce_fun不涉及數據庫鏈接，不貼出來  
    pthread_create(&producer,NULL,produce_fun,NULL);  
    pthread_create(&consumer_1,NULL,consume_fun,NULL);  
    pthread_create(&consumer_2,NULL,consume_fun,NULL);  
//下面的三句非常重要，main線程等待其他三個線程的結束，避免main線程執行到mysql_library_end時退出，而  
//其他三個線程仍然在運行並報錯的情形  
    pthread_join(producer,NULL);  
    pthread_join(consumer_1,NULL);  
    pthread_join(consumer_2,NULL);  
    mysql_library_end();  
    return 0;  
}  
  
void addRecord_d(MYSQL *ptr_db,const char *t_name,int item){  
    char query_buffer[100];  
    sprintf(query_buffer,"insert into %s values(0,%d)",t_name,item);  
    int ret=mysql_query(ptr_db,query_buffer);  
    if(ret){  
        fprintf(stderr,"%s%s\n","cannot add record to ",t_name);  
        return;  
    }  
  
    unsigned long long update_id=mysql_insert_id(ptr_db);  
    printf("add record (%llu,%d) ok.",update_id,item);  
}  
  
void * consume_fun(void *arg){  
    MYSQL db;  
    MYSQL *ptr_db=mysql_init(&db);  
    mysql_real_connect();  
   //藍色部分可以改為其他任何帶操作數據庫語句的代碼  
    //procedure  
    while(1){  
        printf("consumer...");  
        int item=consume(&p);  
        addRecord_d(ptr_db,"test",item);  
    }  
   mysql_thread_end();  
    pthread_exit(NULL);  
}  

 

 

C/C++中調用api設置mysql連接的編碼方式

mysql在C/C++中調用api設置連接mysql的編碼方式有以下幾種方法：

1. mysqli_set_charset
調用示例：

ret = mysql_set_character_set(mysql, "utf8");

說明：
推薦使用的設置方法，與mysql的連接斷開自動重連后仍能保持設置的編碼格式，並且影響mysql_real_escape_string函數功能，使mysql_real_escape_string函數使用設置的編碼格式轉義字符串。
但該函數在mysql5.0.5版本以后才支持，故版本太低者...。
2. 執行sql語句：SET NAMES
調用示例：

ret = mysql_real_query(mysql, "SET NAMES UTF8;",
 (unsigned long) strlen ("SET NAMES UTF8;"));

說明：
使用sql語句執行，只能影響當前與數據庫的連接，斷開自動重連后編碼格式會重置為默認的配置。
3. 設置MYSQL_SET_CHARSET_NAME屬性
調用示例：

ret = mysql_options(mysql, MYSQL_SET_CHARSET_NAME, "utf8");

說明：
跟mysql_set_character_set類似，斷開自動重連后仍能保持設置的編碼格式，只是不會影響到mysql_real_escape_string函數。
並且在mysql5.0.5版本都可以使用，低版本可以使用該方法代替。
需要特別說明的是只有在調用mysql_real_connect連接數據庫之前修改該屬性才會生效。

 

mysql控制自動重連行為

當向mysql server發送statement時，mysql客戶端發現連接失效后會自動嘗試重新連接server。如果"自動重連"狀態是enabled，客戶端嘗試連接server,並在連接成功后重新發送statement.

"自動重連“默認是disabled的。

如果應用程序需要知道連接是否可用（可以退出程序或顯示相應的提示信息），確認“自動重連”是disabled。可以通過調用包含MYSQL_OPT_RECONNECT參數的mysql_options()函數以確認"自動重連"是否disabled:

my_bool reconnect = 0;
mysql_options(&mysql, MYSQL_OPT_RECONNECT, &reconnect);

如果連接已經斷開，mysql_ping()依賴“自動重連”的狀態。如果“自動重連”是enabled,mysql_ping()會重新獲取連接。否則，會返回錯誤。

 

有些客戶端程序可能提供了控制自動重連的功能。比如，mysql默認是允許重連的，但是使用 --skip-reconnect 選項將關閉這個行為。

如果發生了自動重連（比如，調用了mysql_ping()）,自動重連是透明的。為了檢查是否發生了重連，在調用mysql_ping()函數前，先調用mysql_thread_id()函數獲取原始的連接id，然后調用mysql_ping()，在調用 mysql_thread_id()函數，對比兩次 mysql_thread_id()的結果是否變化了。

 

“自動重連”很方便，因為你不需要再實現自己重連代碼，但是一旦發生了自動重連，connection的一些狀態在server端就會被重置，而你的應用程序得不到這些變化的通知。

下面列出連接相關的狀態變化：

• 任何未提交的事務將會回滾並且連接autocommit屬性將會重置

• 事務中的鎖將會被釋放。

• 所有的臨時表將會關閉（並釋放）。

• Session中的變量會重新初始化為系統默認值，包括在statements中顯式聲明的變量，比如SET NAMES。

• 用戶自定義的變量將會丟失。

• Prepared statements將釋放。

• HANDLER 變量將會關閉。

• LAST_INSERT_ID()的值將會重置為0.

• 通過GET_LOCK()獲取的鎖將會釋放。

如果連接失效，可能connection的session在server端依然在運行，當server沒有檢測到客戶端失去連接。在這種情況下，原來connection的鎖依然屬於那個session，你可以調用mysql_kill()函數kill掉它。

 

Linux下C語言連接MySQL找不到mysql.h解決辦法

昨天是把MySQL裝上去了，今天嘗試用C語言訪問連接MySQL，發現使用編譯指令：gcc -I/usr/include/mysql connect.c -lmysqlclient -o connect之后，提示找不到“mysql.h”文件，T_T|||。

       原因其實很簡單了，昨天我只裝了server和client兩個包，對於平常的使用，這已經足夠了，但對於要在Linux下進行數據庫的開發，則還需要安裝devel開發包，並且該開發包的版本應該和我之前所安裝的server和client包版本一致，否則會發生沖突而導致無法安裝。

       server和client包的安裝見上一篇日志：Linux(Fedora 9)卸載自帶的MySQL並安裝MySQL的詳細步驟。

 

       好了，我們來安裝devel包，注意版本要保持一致：

 

[root@localhost install]# rpm -ivh MySQL-devel-community-5.1.46-1.rhel5.i386.rpm
Preparing...                ########################################### [100%]
   1:MySQL-devel-community  ########################################### [100%]

 

 

       這次為了避免再出現問題，我把共享組件包shared也裝上去了，哈哈：

 

[root@localhost install]# rpm -ivh MySQL-shared-community-5.1.46-1.rhel5.i386.rpm
Preparing...                ########################################### [100%]
   1:MySQL-shared-community ########################################### [100%]

 

 

       裝完之后，再編譯就通過了，此時的“mysql.h”已經出現在了/usr/include/mysql目錄下面。Happy~

 

undefined reference to `mysql_init'解決辦法

寫了一個很簡單的測試數據庫連接的程序conn.c如下:

#include <stdio.h>
#include <stdlib.h>
#include "/usr/local/mysql/include/mysql/mysql.h"
#include <string.h>
int main(int argc, char *argv[])
{
MYSQL my_connection;
mysql_init(&my_connection);
if (mysql_real_connect(&my_connection, "localhost", "root", "","mysql",0,NULL,CLIENT_FOUND_ROWS))
{
    printf("Connection success\n"); 
    mysql_close(&my_connection);
}
else
{
    fprintf(stderr, "Connection failed\n");
    if (mysql_errno(&my_connection))
    {
        fprintf(stderr, "Connection error %d: %s\n",mysql_errno(&my_connection),mysql_error(&my_connection));
        }
}
    return EXIT_SUCCESS;
}

gcc編譯:gcc -o conn conn.c出現如下錯誤:
/tmp/ccY0JTdh.o(.text+0x1e): In function `main':
: undefined reference to `mysql_init'
/tmp/ccY0JTdh.o(.text+0x47): In function `main':
: undefined reference to `mysql_real_connect'
/tmp/ccY0JTdh.o(.text+0x6d): In function `main':
: undefined reference to `mysql_close'
/tmp/ccY0JTdh.o(.text+0x97): In function `main':
: undefined reference to `mysql_errno'
/tmp/ccY0JTdh.o(.text+0xad): In function `main':
: undefined reference to `mysql_error'
/tmp/ccY0JTdh.o(.text+0xc0): In function `main':
: undefined reference to `mysql_errno'
collect2: ld returned 1 exit status
出現該錯誤的原因是因為編譯器找不到mysql_init,mysql_close等的具體實現.雖然我們包括了正確的頭文件,但是 我們在編譯的時候還是要連接確定的庫.對於一些常用的函數的實現,gcc編譯器會自動去連接一些常用庫,這樣我們就沒有必要自己去指定了,如:printf函數.在本程序中要通過-L選項包含庫文件的路徑:
gcc -o conn conn.c -L /usr/local/mysql/lib/*.a -lz
通過,用*.a將庫全部包含進來拉,其實只要包含mysqlclient.a就可以. -lz什么意思我也不清楚了

 

undefined reference to 'dlopen';undefined reference to 'dlclose';undefined reference to 'dlerror'等問題

 

在linux下，編譯鏈接的時候，經常會遇到這樣一個問題，undefined reference to.....，引起這個問題的原因在於在鏈接的時候缺少選項。下面舉幾個例子，並給出解決辦法。

1、undefined reference to `dlerror'

　undefined reference to `dlopen'

　undefined reference to `dlerror'；；解決方法：在makefile的 ldflags 后面把選項 -ldl添加上即可

2、undefined reference to `main'；；解決方法：在makefile的 ldflags 后面添加 -nostartfiles 選項

3、undefined reference to `pthread_setspecific'

　  undefined reference to `pthread_key_delete'

     undefined reference to `pthread_key_create'：：解決辦法：在makefile的LDFLAGS后面添加 -lpthread 選項。

最后：：如果undefined reference to后面的內容是在自己的文件中聲明或定義的東西，就不能用這種方法來解決了。這時就需要檢查一下自己的makefile涉及到源文件、頭文件的地方是否出錯了，也有可能是其他的原因