Re: std::string and gcc problem ?
daroman@gmx.net wrote:
i've problem with my small C++ programm. I've just small template
class which represetns a array, everything works fine up to
combination with std::string. I did tried it with M$ VC++ and with GCC
(Cygwin and Linux) and my problem is when i try do this
int main(int argc, char **argv) {
Why do you need 'argc' and 'argv'? You never use them!
array<std::string> a(10);
'array' is undeclared at this point. But presuming you have included
your template definition from below somehow... Supposedly here you
have create an array that internally allocates 10 strings and allows
you the use of all of them, right?
a[0] = "Huhuhu"; <--- with gcc i got a crash !
And with VC++ you don't, correct?
So, 'a[0]' returns a reference to the zeroth element in your array in
the 'a' object. Having looked at the operator[], I don't see any
problem with it. Did you try using a debugger to see what values you
get into the 'std::string::assign'?
std::string = a[0];
This shouldn't even compile! How did you get a crash? Are you
sure you posted your _real_ code?
return 0;
}
the program crashes with segmentation fault on std::string::assign(),
but just with gcc ?!
Can somebode help me solve this problem ?
If it's a GNU-specific problem, GNU people should be able to help.
The code looks fine but only if one assumes that the stuff that you
omitted is correct.
peter
... and here is my code
#ifndef _array_h
#define _array_h
Avoid leading underscores like the plague. Any identifier that begins
with an underscore is reserved in the global namespace.
#include <stdexcept>
No such standard header.
#include <sstream>
#include <stdlib.h>
#include <memory.h>
#ifdef _DEBUG
#include <iostream>
#endif
template <typename T>
class array {
public:
array(size_t ) throw(std::bad_alloc &);
array(const array<T> & ) throw(std::bad_alloc &);
~array();
T& operator[](size_t ) throw(std::out_of_range &);
const T&operator[](size_t ) const throw(std::out_of_range &);
size_t length() const { return size; }
int compare(const array<T> & ) const;
bool operator==(const array<T> &arg ) { return compare(arg) == 0; }
bool operator!=(const array<T> &arg ) { return compare(arg) != 0; }
bool operator<(const array<T> &arg ) { return comapre(arg) < 0; }
bool operator>(const array<T> &arg ) { return compare(arg) > 0; }
Why aren't those operators 'const'?
bool operator!() const { return length > 0; }
private:
T *data;
size_t size;
};
#endif
template <typename T>
array<T>::array(size_t e) throw(std::bad_alloc & )
{
data = NULL; size = 0;
What is that for?
data = new T[e];
size = e;
}
template <typename T>
array<T>::~array()
{
if(data != NULL)
delete [] data;
data = NULL;
size = 0;
}
template <typename T>
const T& array<T>::operator[](size_t idx) const
throw(std::out_of_range &)
{
if(idx > size) {
std::stringstream error;
error << "idx > size " << __FILE__ << "(" << __FUNCTION__ << ":" <<
__LINE__ << ")";
#ifdef _DEBUG
std::cerr << error.c_str() << std::endl;
#endif
throw std::out_of_range(error.str());
}
return data[idx];
}
template <typename T>
T& array<T>::operator[](size_t idx) throw(std::out_of_range &)
{
if(idx > size) {
std::stringstream error;
error << "idx > size " << __FILE__ << "(" << __FUNCTION__ << ":" <<
__LINE__ << ")";
#ifdef _DEBUG
std::cerr << error.str().c_str() << std::endl;
#endif
throw std::out_of_range(error.str());
}
return data[idx];
}
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask