既に定義されているようにリンカーエラーが発生する

Question

リンカーエラーが表示されるので、助けが必要です。 私はDBFieldBaseと呼ばれるクラスを持っているX.dllを持っています。私のワークスペースでは、私はいくつかのデータベースベースのアプリケーションにベクトルを使用しています。私が使用しているベクターは第三者からのものです。 今、もう1つのワークスペースYでベクトルを使用しようとしています。ビジュアルスタジオ2010のリンカ - >入力オプションに対応するインクルードファイルと.libファイルを追加しました。 私はワークスペースXのdllexportを行いました。 dllimportを使用します。 私は

X.lib（X.dll）の下に与えられて取得していますエラー：エラーLNK2005： "パブリック：クラスDBFieldBase * & __thiscallベクトル::演算子[]（unsigned int型）"（？ ？A？sdb.obj

で定義されてPAVDBFieldBase @@@@ QAEAAPAVDBFieldBase @@ I Z、@）@ $ベクトルすでに 私はこのエラーを引き起こしている正確に何を知りません。同じコードがVS6.0で正常にコンパイルされました。今はVS2010でビルドしようとしています。何かが欠けている場合は私に知らせてください。 ありがとうございます。

P.S.私は同様の問題についてインターネット上のソリューションを検索しようとしましたが、残念ながら成功しませんでした。

第三者からであるベクトルのコードは以下の通りである：X.DLLで

class os_vector 
{ 
public: 
typedef T      value_type; 
typedef OS_REFERENCE(T)  reference; 
typedef OS_CONST_REFERENCE(T) const_reference; 
typedef OS_SIZE_TYPE(T)  size_type; 
typedef OS_DIFF_TYPE(T)  difference_type; 
typedef OS_ALLOCATOR(T)  allocator_type; 

typedef T*  pointer; 
typedef const T* const_pointer; 

typedef T*  iterator; 
typedef const T* const_iterator; 

typedef os_reverse_iterator 
    < 
    T*, 
    T, 
    OS_REFERENCE(T), 
    T*, 
    OS_DIFF_TYPE(T) 
    > reverse_iterator; 
typedef os_reverse_iterator 
    < 
    const T*, 
    T, 
    OS_CONST_REFERENCE(T), 
    const T*, 
    OS_DIFF_TYPE(T) 
    > const_reverse_iterator; 

// Construct me to be an empty vector. 
os_vector() : 
    start_(0), 
    finish_(0), 
    end_of_storage_(0), 
    alloc_() 
    { 
    } 

// Construct me to be an empty vector. 
explicit os_vector(const OS_ALLOCATOR(T) & alloc) : 
    start_(0), 
    finish_(0), 
    end_of_storage_(0), 
    alloc_(alloc) 
    { 
    } 

// Construct me to contain `n` (>0) elements. Each element will be 
// a copy of `value`. 
os_vector 
    (
    size_type n, 
    const T& value, // = T() 
    const OS_ALLOCATOR(T) & alloc // = OS_ALLOCATOR(T)() 
) : 
    start_(0), 
    finish_(0), 
    end_of_storage_(0), 
    alloc_(alloc) 
    { 
    assign(n, value); 
    } 

os_vector (size_type n, const T& value) : 
    start_(0), 
    finish_(0), 
    end_of_storage_(0), 
    alloc_() 
    { 
    assign(n, value); 
    } 

os_vector (size_type n) : 
    start_(0), 
    finish_(0), 
    end_of_storage_(0), 
    alloc_() 
    { 
    assign(n, T()); 
    } 


// Construct me to contain copies of all the elements in `original`. 
os_vector(const os_vector OS_ALLOCATE_ARG_2(T, Allocator) & original) : 
    start_(0), 
    finish_(0), 
    end_of_storage_(0), 
    alloc_(original.get_allocator()) 
    { 
    assign(original.begin(), original.end()); 
    } 

// Construct me to contain all of the elements in the 
// range [`first`, `last`). 
    template< class InIt > 
    os_vector 
    (
    InIt first, 
    InIt last, 
    const OS_ALLOCATOR(T) & alloc = OS_ALLOCATOR(T)() 
    ) : 

    start_(0), 
    finish_(0), 
    end_of_storage_(0), 
    alloc_(alloc) 
    { 
    assign(first, last); 
    } 

// Destroy me. 
~os_vector() 
    { 
    clear(); 
    } 

// Replace my contents with a copy of the elements in `original`, 
// resizing if necessary. 
os_vector OS_ALLOCATE_ARG_2(T, Allocator) & operator= 
    (
    const os_vector OS_ALLOCATE_ARG_2(T, Allocator) & original 
); 

// Remove all my current elements, and then insert the elements 
// in range [`first`, `last`). 
void assign(const_iterator first, const_iterator last) 
    { 
    if (first == begin()) 
    erase(begin() + (last - first), end()); 
    else 
    assign_aux(first, last); 
    } 


    // Remove all my current elements, and then insert the elements 
    // in range [`first`, `last`). 
    template< class InIt > 
    void assign(InIt first, InIt last) 
    { 
    assign_aux(first, last); 
    } 


// Remove all my current elements, and then insert `n` copies of 
// `value`. 
void assign(size_type n, const T& value); 


    void assign(size_type n) 
    { 
    assign(n, T()); 
    } 


// Return a copy of the allocator I am using. 
allocator_type get_allocator() const 
    { 
    return alloc_; 
    } 

// Return a random access iterator positioned at my first element. 
iterator begin() 
    { 
    return start_; 
    } 

// Return a constant random access iterator positioned at my first 
// element. 
const_iterator begin() const 
    { 
    return start_; 
    } 

// Return a random access iterator positioned immediately after my 
// last element. 
iterator end() 
    { 
    return finish_; 
    } 

// Return a constant random access iterator positioned immediately after 
// my last element. 
const_iterator end() const 
    { 
    return finish_; 
    } 

// Return a random access reverse iterator positioned immediately after 
// my last element. 
reverse_iterator rbegin() 
    { 
    return reverse_iterator(end()); 
    } 

// Return a constant random access reverse iterator positioned 
// immediately after my last element. 
const_reverse_iterator rbegin() const 
    { 
    return const_reverse_iterator(end()); 
    } 

// Return a random access reverse iterator positioned at my first 
// element. 
reverse_iterator rend() 
    { 
    return reverse_iterator(begin()); 
    } 

// Return a constant random access reverse iterator positioned at my 
// first element. 
const_reverse_iterator rend() const 
    { 
    return const_reverse_iterator(begin()); 
    } 

// Return the number of elements that I contain. 
size_type size() const 
    { 
    return end() - begin(); 
    } 

// Return the maximum number of elements that I can contain. 
size_type max_size() const 
    { 
    return alloc_.max_size(); 
    } 

// Cause myself to hold `n` elements, using `value` to expand 
// myself if necessary. 
void resize(size_type n, T value) 
    { 
    if (n > size()) 
    insert(end(), n - size(), value); 
    else 
    erase(begin() + n, end()); 
    } 

// Cause myself to hold `n` elements using the default constructor 
// to expand myself if necessary. 
void resize(size_type n) 
    { 
    resize(n, T()); 
    } 

// Return the number of elements that I can contain without allocating 
// more memory. 
size_type capacity() const 
    { 
    return end_of_storage_ - start_; 
    } 

// Return true if I contain no elements. 
bool empty() const 
    { 
    return begin() == end(); 
    } 

// Change my capacity to be at least `n`. Does not affect my 
// current size. 
void reserve(size_type n); 

// Return a reference to my `n`th element. 
reference operator[](size_type n) 
    { 
    OS_ASSERT_NOT_EMPTY(empty()) 
    OS_ASSERT_INDEX_OK(n, 0, size() - 1) 
    return *(begin() + n); 
    } 

// Return a constant reference to my `n`th element. 
const_reference operator[](size_type n) const 
    { 
    OS_ASSERT_NOT_EMPTY(empty()) 
    OS_ASSERT_INDEX_OK(n, 0, size() - 1) 
    return *(begin() + n); 
    } 

// Return a reference to my `n`th element. 
reference at(size_type n) 
    { 
    if (n >= size()) 
    os_throw_out_of_range(); 
    return *(begin() + n); 
    } 

// Return a constant reference to my `n`th element. 
const_reference at(size_type n) const 
    { 
    if (n >= size()) 
    os_throw_out_of_range(); 
    return *(begin() + n); 
    } 

// Return a reference to my first element. 
reference front() 
    { 
    OS_ASSERT_NOT_EMPTY(empty()) 
    return *begin(); 
    } 

// Return a constant reference to my first element. 
const_reference front() const 
    { 
    OS_ASSERT_NOT_EMPTY(empty()) 
    return *begin(); 
    } 

// Return a reference to my last element. 
reference back() 
    { 
    OS_ASSERT_NOT_EMPTY(empty()) 
    return *(end() - 1); 
    } 

// Return a constant reference to my last element. 
const_reference back() const 
    { 
    OS_ASSERT_NOT_EMPTY(empty()) 
    return *(end() - 1); 
    } 

// Add `value` at my end. 
void push_back(const_reference value) 
    { 
    if (finish_ != end_of_storage_) 
    { 
    alloc_.construct(finish_, value); 
    ++finish_; 
    } 
    else 
    insert_aux(end(), value); 
    } 

// Erase my last element. 
void pop_back() 
    { 
    OS_ASSERT_NOT_EMPTY_ELSE(empty()) 
    { 
    --finish_; // not on a single line due to Borland problem 
    alloc_.destroy(finish_); 
    } 
    } 

// Insert `value` at `pos` and return an iterator pointing to the new 
// element's position. 
iterator insert(iterator pos, const T& value) 
    { 
    size_type n = pos - begin(); 
    if (finish_ != end_of_storage_ && pos == finish_) 
    { 
    alloc_.construct(finish_, value); 
    ++finish_; 
    } 
    else 
    insert_aux(pos, value); 
    return begin() + n; 
    } 

// Insert an element constructed with the default constructor at `pos` and 
// return an iterator pointing to the new element's position. 
// not standard, left for backward compatibility 

iterator insert(iterator pos) 
    { 
    return insert(pos, T()); 
    } 



// Insert `n` copies of `value` at `pos`. 
void insert(iterator pos, size_type n, const T& value); 

// Insert copies of the elements in range [`first`, `last`) at `pos`. 

    template< class InIt > 
    void insert(iterator pos, InIt first, InIt last); 


// Erase the element at `pos`. 
iterator erase(iterator pos) 
    { 
    if (!(pos + 1 == end())) 
    copy(pos + 1, end(), pos); 
    pop_back(); 
    return pos; 
    } 

// Erase the elements in range [`first`, `last`). 
iterator erase(iterator first, iterator last) 
    { 
    iterator i = copy(last, end(), first); 
    destroy(i, finish_, alloc_); 
    finish_ = finish_ - (last - first); 
    return first; 
    } 

// Swap my contents with those of `original`. 
void swap(os_vector OS_ALLOCATE_ARG_2(T, Allocator) & original) 
    { 
    if (!(alloc_ == original.alloc_)) 
    { 
    os_vector OS_ALLOCATE_ARG_2(T, Allocator) tmp(*this); 
    assign(original.begin(), original.end()); 
    original.assign(tmp.begin(), tmp.end()); 
    } 
    else 
    { 

     ::swap(start_, original.start_); 
     ::swap(finish_, original.finish_); 
     ::swap(end_of_storage_, original.end_of_storage_); 
     ::swap(alloc_, original.alloc_); 

    } 
    } 

// Erase all of my elements. 
void clear() 
    { 
    if (start_) 
    { 
    destroy(start_, finish_, alloc_); 
    alloc_.deallocate(start_); 
    } 
    start_ = finish_ = end_of_storage_ = 0; 
    } 

protected: 
void insert_aux(T* pos, const T& value); 


    template< class InIt > 
    void assign_aux(InIt first, InIt last); 


private: 
// Data members. 
iterator start_; 
iterator finish_; 
iterator end_of_storage_; 
allocator_type alloc_; 


public: 
// Construct me to contain n (>0) elements. Each element will be 
// default constructed. 
// This remains for compatibility. It will be removed in a future release. 
os_vector 
    (
    const OS_ALLOCATOR(T) & alloc, 
    size_type n 
) : 
    start_(0), 
    finish_(0), 
    end_of_storage_(0), 
    alloc_(alloc) 
    { 
    assign(n, T()); 
    } 

// Construct me to contain n (>0) elements. Each element will be 
// a copy of `value`. 
// This remains for compatibility. It will be removed in a future release. 
os_vector 
    (
    const OS_ALLOCATOR(T) & alloc, 
    size_type n, 
    const T& value 
) : 
    start_(0), 
    finish_(0), 
    end_of_storage_(0), 
    alloc_(alloc) 
    { 
    assign(n, value); 
    } 

// Construct me to contain copies of all the elements in `original`. 
// This remains for compatibility. It will be removed in a future release. 
os_vector 
    (
    const OS_ALLOCATOR(T) & alloc, 
    const os_vector OS_ALLOCATE_ARG_2(T, Allocator) & original 
) : 
    start_(0), 
    finish_(0), 
    end_of_storage_(0), 
    alloc_(alloc) 
    { 
    assign(original.begin(), original.end()); 
    } 

// Construct me to contain all of the elements in the 
// range [`first`, `last`). 
// This remains for compatibility. It will be removed in a future release. 
os_vector 
    (
    const OS_ALLOCATOR(T) & alloc, 
    const_iterator first, 
    const_iterator last 
) : 
    start_(0), 
    finish_(0), 
    end_of_storage_(0), 
    alloc_(alloc) 
    { 
    assign(first, last); 
    } 

// Erase all of my elements. 
// This remains for compatibility. It will be removed in a future release. 
void erase() 
    { 
    clear(); 
    } 
}; 

を私はクラスがメンバ変数と関数との私たちの私たちの通常のクラスのようにDBFieldBase持っています。使用量が以下に与えられるiはベクトルを使用しているクラスのいずれかでYワークスペースで

：

private: 
vector < DBFieldBase *> &  GetASDVect (void); 
vector <DBFieldBase *>   m_ASDVect; 

が同じヘッダファイル内のクラス外GetASDVectの定義があります。そのインライン

inline vector <DBFieldBase *> & ASD_sdb::GetASDVect (void) 
{ 
return this->m_ASDVect; 
} 

私の側から他のものが必要な場合は教えてください。

Answer 1

シンボルを複数回定義しました。私はシンボルがX.dllとY.dllの両方で定義されていると思いますか？