Was geht hier vor?

HarteWare

Hallo,

mir ist in Principles and Practice using C++ by Bjarne Stroustrup ein Tippfehler (ich glaube?) aufgefallen, habe es zum Spaß aber mal so übernommen und es kompiliert fehlerfrei:

vector::vector(const vector& arg)
    :sz{arg.sz}, elem{new double[arg.sz]}
{
    copy(arg, arg + sz, elem);  // std::copy
}

Eigentlich müsste das doch so aussehen:

copy(arg.elem, arg.elem + sz, elem);  // std::copy

Und beim copy-assignment-operator schreibt er es dann auch so.

Was mich wundert ist, dass Ersteres kompiliert und warum. Könnte mir das bitte jemand kurz erklären?

LG

hustbaer

Hat die Klasse vielleicht einen operator double* ?

Jodocus

http://www.stroustrup.com/Programming/PPP2errata.html
Poste doch mal deinen ganzen Code.

HarteWare

Ich habe es schon korrigiert, aus Angst, aber die Klasse sieht so aus (Uni Aufgabe, ich gehe davon aus std::vector zu nehmen würde man nicht akzeptieren^^):

template<typename T>
class Stack {
public:
    Stack() = default;
    ~Stack();

    Stack(const Stack&);
    Stack& operator=(const Stack&);

    Stack(Stack&&);
    Stack& operator=(Stack&&);

    std::size_t size() const { return sz; }
    bool empty() const { return !sz; }

    T& top();
    const T& top() const;

    void push(const T& value);
    void pop();

    void reserve(std::size_t n); // increase space to n

private:
    T* elem{};
    std::size_t sz{};
    std::size_t space{};
};

Visual Studio 2017 RC, kompiliert Fehlerfrei (nachdem ich mit C4996 zu kämpfen hatte, welcher aber auch kommt bei "richtiger" Anwendung).

call with parameters that may be unsafe - this call relies on the caller to check that the passed values are correct.

template<typename T>
Stack<T>::Stack(const Stack& other)
    :elem{ new T[other.sz] }, sz{ other.sz }
{
    std::copy(other, other + sz, elem);
}

Das errata macht genauso wenig Sinn:

s/copy(arg,arg.sz,elem);/copy(arg.elem,arg.elem.sz,elem);/

elem ist ein T* und meines Wissens nach haben pointer keinen Member 'sz'. Das soll ja wohl heißen

copy(arg,arg+sz,elem);/copy(arg.elem, arg.elem + sz, elem

Aber keine Ahnung, vielleicht bilde ich mir nur etwas ein. Ich nehme es keinem übel, wenn in >1000 Seiten noch irgendwo ein paar Fehler sind.