008
03.02.2009, 23:46 Uhr
0xdeadbeef
Gott
(Operator)
|
Baaaah, ja, ja, logisch. Du läufst da in eine der Fallen von C++ - wenn kein "copy assignment operator" deklariert ist, wird implizit einer definiert. Das bedeutet, du musst explizit einen deklarieren - dafür würde es sich wohl lohnen, das Kopieren in eine Funktionsvorlage auszulagern, etwa so:
| C++: |
#include <cstddef>
#include <iostream>
template<typename Type, typename Allocated = Type>
class SerializableArray {
public:
SerializableArray() : data_(NULL), size_(0) { }
SerializableArray(std::size_t n) : data_(NULL), size_(0) { alloc(n); }
~SerializableArray() { delete[] data_; }
std::size_t size() const { return size_; }
Type &operator[](std::size_t index) { return data_[index]; }
Type const &operator[](std::size_t index) const { return data_[index]; }
template<typename T, typename A>
SerializableArray &operator=(SerializableArray<T, A> const &other) {
return copy(other);
}
SerializableArray &operator=(SerializableArray const &other) {
return copy(other);
}
private:
template<typename T, typename A>
SerializableArray ©(SerializableArray<T, A> const &other) {
alloc(other.size());
for(std::size_t i = 0; i < size(); ++i) {
data_[i] = other[i];
}
return *this;
}
void alloc(std::size_t n) {
delete[] data_;
data_ = new Allocated[n];
size_ = n;
}
Type *data_;
std::size_t size_;
};
template<typename T, typename A>
std::ostream &operator<<(std::ostream &out, SerializableArray<T, A> const &s) {
out << s[0];
for(std::size_t i = 1; i < s.size(); ++i) {
out << ',' << s[i];
}
return out;
}
int main() {
SerializableArray<int> s1(10), s3;
SerializableArray<short> s2;
for(std::size_t i = 0; i < s1.size(); ++i) {
s1[i] = i;
}
s2 = s1;
s3 = s1;
std::cout << s1 << std::endl;
std::cout << s2 << std::endl;
}
|
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra |
joa habs im moment dann nun eben mit ner copy-methode gelöst, aber so isses natürlich deutlich praktischer