getting a linker error as already defined operator - c++

Question

i am seeing the linker error so need your help.
i have X.dll in which i have a class called DBFieldBase. in my workspace X i am using vector for some data base related applications. the vector which i am using is from thirdparty ospace.
now i am trying to use vector in one more workspace Y. I added the corresponding include files and .lib files in linker->input option in visual studio 2010.
I did dllexport for workspace X and to use it in Y i am using dllimport.
The error which i am getting is given below
X.lib(X.dll) : error LNK2005: "public: class DBFieldBase * &
__thiscall vector::operator[](unsigned int)" (??A?$vector#PAVDBFieldBase####QAEAAPAVDBFieldBase##I#Z) already
defined in sdb.obj
I dont know exactly what is causing this error. The same code was getting successfully compiled in VS 6.0 now i am trying to build it in VS2010. Please let me know if i am missing anything or so.
Thanks in advance.
P.S. I tried to search the solution on internet for similar problem but unfortunately no success.
the code for vector which is from third party is given below:
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();
}
};
in X.DLL i have a class DBFieldBase its like our our normal class with member variables and functions.
in Y workspace in one of the class i am using vector that usage is given below:
private:
vector < DBFieldBase *> & GetASDVect (void);
vector <DBFieldBase *> m_ASDVect;
Then outside class in same header file there is definition for GetASDVect. its inline
inline vector <DBFieldBase *> & ASD_sdb::GetASDVect (void)
{
return this->m_ASDVect;
}
Let me know if you need anything else from my side.

Answer 1

You've defined a symbol multiple times. I guess a symbol is defined in both X.dll and Y.dll ?