Worum geht es bei diesem Fehler?

Question

ALLE,

Ich benutze Anjuta, um meine Entwicklung zu tun.

Ich habe ein Projekt für meine Hauptanwendung erstellt und dann 2 weitere erstellt: 1 für die statische Bibliothek (libdbinterface.a) und 1 für die dynamische Bibliothek (libsqlite_lib.so).

Diese beiden Bibliotheken enthalten jeweils eine exportierte Klasse: libdbinterface.a - class Datenbank, libsqlite_lib.so - public SQLiteDatabase: public Database.

Jetzt versuche ich libdbinterface.a zu libsqlite_lib.so zu verknüpfen.

So in Anjuta habe ich für das Ziel der "Linker Option" folgende libsqlite_lib.so:

-L/home/igor/dbhandler/Debug/dbinterface -ldbinterface

jedoch , die ich von Linker erhielt folgende Fehler zu kompilieren versuchen:

/usr/lib/gcc/x86_64-pc-linux-gnu/4.8.4/../../../../x86_64-pc-linux-gnu/bin/ld: /home/igor/dbhandler/Debug/dbinterface/libdbinterface.a(database.o): relocation R_X86_64_32S against `_ZTV8Database' can not be used when making a shared object; recompile with -fPIC 

ich habe versucht, mit -fPIC neu kompilieren libsqlite_lib.so ausdrücklich hinzugefügt, um „C++ Optionen“ davon Projekt, aber das hat es nicht gelöst - ich bekomme immer noch den gleichen Fehler.

Leider versucht Google, wie zu verknüpfen .a und .so ist nicht hilfreich.

Kann jemand etwas Licht auf, wie man diesen Fehler beheben?

TIA.

[EDIT] libsqlite_lib.so Makefile - https://bpaste.net/show/1495231e58cc libdbinterface.a Makefile - https://bpaste.net/show/3a71c119d0fc

libdbinterface.a enthält 2 Dateien databse.h:

#ifndef DBMANAGER_DATABASE 
#define DBMANAGER_DATABASE 

class Field 
{ 
public: 
    Field(const std::string &columnName, const std::string &columnType, const std::string &columnDefaultValue = "", const bool columnIsNull = false, const bool columnPK = false) 
    { 
     column_name = columnName; 
     column_type = columnType; 
     column_defaultValue = columnDefaultValue; 
     column_isNull = columnIsNull; 
     column_pk = columnPK; 
    } 
private: 
    std::string column_name, column_type, column_defaultValue; 
    bool column_isNull, column_pk; 
}; 

struct FKField 
{ 
    FKField(const std::string &table_name, const std::string &original_field, const std::string &referenced_field) 
    { 
     tableName = table_name; 
     originalField = original_field; 
     referencedField = referenced_field; 
    } 
    std::string tableName, originalField, referencedField; 
}; 

class Table 
{ 
public: 
    Table(const std::string &tableName, const std::vector<Field> &tableFields, const std::map<int,std::vector<FKField> > &foreignKeys) 
    { 
     table_name = tableName; 
     table_fields = tableFields; 
     foreign_keys = foreignKeys; 
    } 
    const std::string &GetTableName() { return table_name; } 
    std::map<int,std::vector<FKField> > &GetForeignKeyVector() { return foreign_keys; } 
private: 
    std::string table_name; 
    std::vector<Field> table_fields; 
    std::map<int,std::vector<FKField> > foreign_keys; 
}; 

#ifdef WIN32 
class __declspec(dllexport) Database 
#else 
class Database 
#endif 
{ 
private: 
    struct Impl; 
    Impl *pimpl; 
public: 
    Database(); 
    virtual ~Database(); 
    Impl &GetTableVector(); 
    static void *operator new(std::size_t size); 
    static void operator delete(void *ptr, std::size_t size); 
    virtual int Connect(const char *selectedDSN, std::vector<std::wstring> &errorMsg); 
    virtual int GetTableListFromDb(std::string &) { return 0; } 
}; 

#endif 

und database.cpp:

#ifdef WIN32 
#include <windows.h> 
#endif 
#include <map> 
#include <vector> 
#include <string> 
#include <sqlext.h> 
#include "database.h" 

struct Database::Impl 
{ 
    std::vector<Table> m_tables; 
}; 

Database::Database() : pimpl(new Impl) 
{ 
} 

Database::~Database() 
{ 
    delete pimpl; 
} 

void *Database::operator new(std::size_t size) 
{ 
    return ::operator new(size); 
} 

void Database::operator delete(void *ptr, std::size_t size) 
{ 
    return ::operator delete(ptr); 
} 

Database::Impl &Database::GetTableVector() 
{ 
    return *pimpl; 
} 

int Database::Connect(const char *selectedDSN, std::vector<std::wstring> &errorMsg) 
{ 
    selectedDSN = selectedDSN; 
    errorMsg = errorMsg; 
    return 0; 
} 

libsqlite_lib.so hat auch 2 Dateien: database_sqlite.h

#ifndef DBMANAGER_SQLITE 
#define DBMANAGER_SQLITE 

#ifdef WIN32 
class __declspec(dllexport) SQLiteDatabase : public Database 
#else 
class SQLiteDatabase : public Database 
#endif 
{ 
public: 
    SQLiteDatabase(); 
    ~SQLiteDatabase(); 
    virtual int Connect(const char *selectedDSN, std::vector<std::wstring> &errorMsg); 
    virtual int GetTableListFromDb(std::vector<std::wstring> &errorMsg); 
protected: 
    void GetErrorMessage(int code, std::wstring &errorMsg); 
private: 
    sqlite3 *m_db; 
}; 

#endif 

und database_sqlite.cpp mit der tatsächlichen Implementierung. [/ EDIT]

Answer 1

Nun, anscheinend ist die Lösung, statische Bibliothek mit "-fPIC", nicht die dynamische neu zu erstellen.

Vielen Dank für das Lesen.