C++Talk.NET

Michael Trocken · Guest

Um schnelle Operationen auf dem Stack mit der Flexibilität von
»vector« zu verbinden, habe ich einen Container »fastvector«
(Beispiel-Quelltext s.u.) geschrieben, der die ersten Elemente auf dem
Stack anlegt (entsprechende Deklaration des Containers vorausgesetzt)
und erst ab einer bestimmten Anzahl von Elementen auf den Heap
ausweicht.

Was müsste man bei einer allgemeinen Verwendung ggf. beachten? Ein
Problem dürfte beispielsweise sein, dass bei sehr großen Typen T der
Stack zu stark belastet wird, was sich aber wiederum durch
Spezialisierung lösen ließe.

Was könnte noch Schwierigkeiten bereiten?

//~~ zunächst eine Hilfsklasse: ~~
template<typename T, size_t C>
class simple_array {
T a_[C];
size_t sz_;

public:
simple_array() : sz_(0) {}

typedef T* iterator;
typedef const T* const_iterator;

void push_back(const T& x) { a_[sz_++] = x; }

size_t size() const { return sz_; }
size_t capacity() const { return C; }
void clear() { sz_ = 0; }

iterator begin() { return a_; }
const_iterator begin() const { return a_; }

iterator end() { return a_ + sz_; }
const_iterator end() const { return a_ + sz_; }
};

//~~ der eigentliche »fastvector«: ~~
template<typename T, size_t C = 20>
class fastvector {
simple_array<T, C> st_;
std::vector<T> vec_;
bool st_active;

void activate_vec() {
vec_.assign(st_.begin(), st_.end());
st_active = false;
}

public:
fastvector() : st_active(true) {}

typedef T* iterator;
typedef const T* const_iterator;

void push_back(const T& x) {
if (st_active) {
st_.push_back(x);
if (st_.size() >= C) activate_vec();
}
else
vec_.push_back(x);
}

iterator insert(iterator pos, const T& x) {
if (st_active) activate_vec();
return vec_.insert(pos, x);
}

template <typename input_iterator>
void insert(iterator pos,
input_iterator first,
input_iterator last) {
if (st_active) activate_vec();
vec_.insert(pos, first, last);
}

size_t size() const {
return st_active? st_.size() : vec_.size();
}
size_t capacity() const {
return st_active? st_.capacity() : vec_.capacity();
}
void clear() {
st_.clear(); st_active = true; vec_.clear();
}

iterator begin() {
return st_active? st_.begin() : vec_.begin();
}
const_iterator begin() const {
return st_active? st_.begin() : vec_.begin();
}

iterator end() {
return st_active? st_.end() : vec_.end();
}
const_iterator end() const {
return st_active? st_.end() : vec_.end();
}
};

Gruß,
Michael

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Hubert Schmid · Guest

[email]s1234569 (AT) hotmail (DOT) com[/email] (Michael Trocken) writes:
[gekürzt]

Olaf Krzikalla · Guest

Hi,

Hubert Schmid wrote:

Markus Schaaf · Guest

"Olaf Krzikalla" <Entwicklung (AT) reico (DOT) de> schrieb:

André Pönitz · Guest

Olaf Krzikalla <Entwicklung (AT) reico (DOT) de> wrote: