История изменений

Исправление dissident, 29.10.18 22:48 (текущая версия) :

by a new-expression

Прицепился к malloc'у. Ну хорошо, не malloc, так new. А это что не array object?

int* array = operator new(sizeof(int)*N);

? Если даже by definition нет, то «класть» туда int'ы и обращаться к ним по

array[i]

вполне себе можно.

Если нет, то Herb Sutter в примере из exceptional C++ (item 12, 13) явно не знает C++:

template <class T> class StackImpl 
{
/*????*/:
  StackImpl(size_t size=0);
  ~StackImpl();
  void Swap(StackImpl& other) throw();

  T*     v_;      // ptr to a memory area big
  size_t vsize_;  //  enough for 'vsize_' T's
  size_t vused_;  // # of T's actually in use

private:
  // private and undefined: no copying allowed
  StackImpl( const StackImpl& );
  StackImpl& operator=( const StackImpl& );
};

template <class T> 
StackImpl<T>::StackImpl( size_t size )
  : v_( static_cast<T*>
          ( size == 0
            ? 0
            : operator new(sizeof(T)*size) ) ),
    vsize_(size),
    vused_(0)
{
}

template <class T> 
class Stack : private StackImpl<T>
{
public:
  Stack(size_t size=0)
    : StackImpl<T>(size)
  {
  }

// construct() constructs a new object in 
// a given location using an initial value
//
template <class T1, class T2>
void construct( T1* p, const T2& value )
{
  new (p) T1(value);
}

Stack(const Stack& other) 
  : StackImpl<T>(other.vused_)
{
  while( vused_ < other.vused_ )
  {
    construct( v_+vused_, other.v_[vused_] );
    ++vused_;
  }
}

T& Top() 
{
  if( vused_ == 0 )
  {
    throw "empty stack";
  }
  return v_[vused_-1];
}

Посмотри на конструкцию

v_+vused

в Stack copy constructor. Посмотри на конструкцию

return v_[vused_-1]

в Stack::Top.

Исправление dissident, 29.10.18 22:47:

by a new-expression

Прицепился к malloc'у. Ну хорошо, не malloc, так new. А это что не array object?

int* array = operator new(sizeof(int)*N);

? Если даже by definition нет, то «класть» туда int'ы и обращаться к ним по

array[i]

вполне себе можно.

Если нет, то Herb Sutter в примере из exceptional C++ (item 12, 13) явно не знает C++:

template <class T> class StackImpl 
{
/*????*/:
  StackImpl(size_t size=0);
  ~StackImpl();
  void Swap(StackImpl& other) throw();

  T*     v_;      // ptr to a memory area big
  size_t vsize_;  //  enough for 'vsize_' T's
  size_t vused_;  // # of T's actually in use

private:
  // private and undefined: no copying allowed
  StackImpl( const StackImpl& );
  StackImpl& operator=( const StackImpl& );
};

template <class T> 
StackImpl<T>::StackImpl( size_t size )
  : v_( static_cast<T*>
          ( size == 0
            ? 0
            : operator new(sizeof(T)*size) ) ),
    vsize_(size),
    vused_(0)
{
}

template <class T> 
class Stack : private StackImpl<T>
{
public:
  Stack(size_t size=0)
    : StackImpl<T>(size)
  {
  }

// construct() constructs a new object in 
// a given location using an initial value
//
template <class T1, class T2>
void construct( T1* p, const T2& value )
{
  new (p) T1(value);
}

Stack(const Stack& other) 
  : StackImpl<T>(other.vused_)
{
  while( vused_ < other.vused_ )
  {
    construct( v_+vused_, other.v_[vused_] );
    ++vused_;
  }
}

T& Top() 
{
  if( vused_ == 0 )
  {
    throw "empty stack";
  }
  return v_[vused_-1];
}

Посмотри на конструкцию

"v_+vused"

в Stack copy constructor. Посмотри на конструкцию

return v_[vused_-1]

в Stack::Top.

Исправление dissident, 29.10.18 22:46:

by a new-expression

Прицепился к malloc'у. Ну хорошо, не malloc, так new. А это что не array object?

int* array = operator new(sizeof(int)*N);

? Если даже by definition нет, то «класть» туда int'ы и обращаться к ним по array вполне себе можно.

Если нет, то Herb Sutter в примере из exceptional C++ (item 12, 13) явно не знает C++:

template <class T> class StackImpl 
{
/*????*/:
  StackImpl(size_t size=0);
  ~StackImpl();
  void Swap(StackImpl& other) throw();

  T*     v_;      // ptr to a memory area big
  size_t vsize_;  //  enough for 'vsize_' T's
  size_t vused_;  // # of T's actually in use

private:
  // private and undefined: no copying allowed
  StackImpl( const StackImpl& );
  StackImpl& operator=( const StackImpl& );
};

template <class T> 
StackImpl<T>::StackImpl( size_t size )
  : v_( static_cast<T*>
          ( size == 0
            ? 0
            : operator new(sizeof(T)*size) ) ),
    vsize_(size),
    vused_(0)
{
}

template <class T> 
class Stack : private StackImpl<T>
{
public:
  Stack(size_t size=0)
    : StackImpl<T>(size)
  {
  }

// construct() constructs a new object in 
// a given location using an initial value
//
template <class T1, class T2>
void construct( T1* p, const T2& value )
{
  new (p) T1(value);
}

Stack(const Stack& other) 
  : StackImpl<T>(other.vused_)
{
  while( vused_ < other.vused_ )
  {
    construct( v_+vused_, other.v_[vused_] );
    ++vused_;
  }
}

T& Top() 
{
  if( vused_ == 0 )
  {
    throw "empty stack";
  }
  return v_[vused_-1];
}

Посмотри на конструкцию

"v_+vused"

в Stack copy constructor. Посмотри на конструкцию

return v_[vused_-1]

в Stack::Top.

Исправление dissident, 29.10.18 22:45:

by a new-expression

Прицепился к malloc'у. Ну хорошо, не malloc, так new. А это что не array object?

int* array = operator new(sizeof(int)*N);

Если нет, то Herb Sutter в примере из exceptional C++ (item 12, 13) явно не знает C++:

template <class T> class StackImpl 
{
/*????*/:
  StackImpl(size_t size=0);
  ~StackImpl();
  void Swap(StackImpl& other) throw();

  T*     v_;      // ptr to a memory area big
  size_t vsize_;  //  enough for 'vsize_' T's
  size_t vused_;  // # of T's actually in use

private:
  // private and undefined: no copying allowed
  StackImpl( const StackImpl& );
  StackImpl& operator=( const StackImpl& );
};

template <class T> 
StackImpl<T>::StackImpl( size_t size )
  : v_( static_cast<T*>
          ( size == 0
            ? 0
            : operator new(sizeof(T)*size) ) ),
    vsize_(size),
    vused_(0)
{
}

template <class T> 
class Stack : private StackImpl<T>
{
public:
  Stack(size_t size=0)
    : StackImpl<T>(size)
  {
  }

// construct() constructs a new object in 
// a given location using an initial value
//
template <class T1, class T2>
void construct( T1* p, const T2& value )
{
  new (p) T1(value);
}

Stack(const Stack& other) 
  : StackImpl<T>(other.vused_)
{
  while( vused_ < other.vused_ )
  {
    construct( v_+vused_, other.v_[vused_] );
    ++vused_;
  }
}

T& Top() 
{
  if( vused_ == 0 )
  {
    throw "empty stack";
  }
  return v_[vused_-1];
}

Посмотри на конструкцию

"v_+vused"

в Stack copy constructor. Посмотри на конструкцию

return v_[vused_-1]

в Stack::Top.

Исходная версия dissident, 29.10.18 22:44:

by a new-expression

Прицепился к malloc'у. Ну хорошо, не malloc, так new. А это что не array object?

int* array = operator new(sizeof(int)*N);

Если нет, то Herb Sutter в примере из exceptional C++ (item 12, 13) явно не знает C++:

template <class T> class StackImpl 
{
/*????*/:
  StackImpl(size_t size=0);
  ~StackImpl();
  void Swap(StackImpl& other) throw();

  T*     v_;      // ptr to a memory area big
  size_t vsize_;  //  enough for 'vsize_' T's
  size_t vused_;  // # of T's actually in use

private:
  // private and undefined: no copying allowed
  StackImpl( const StackImpl& );
  StackImpl& operator=( const StackImpl& );
};

template <class T> 
StackImpl<T>::StackImpl( size_t size )
  : v_( static_cast<T*>
          ( size == 0
            ? 0
            : operator new(sizeof(T)*size) ) ),
    vsize_(size),
    vused_(0)
{
}

template <class T> 
class Stack : private StackImpl<T>
{
public:
  Stack(size_t size=0)
    : StackImpl<T>(size)
  {
  }

// construct() constructs a new object in 
// a given location using an initial value
//
template <class T1, class T2>
void construct( T1* p, const T2& value )
{
  new (p) T1(value);
}

Stack(const Stack& other) 
  : StackImpl<T>(other.vused_)
{
  while( vused_ < other.vused_ )
  {
    construct( v_+vused_, other.v_[vused_] );
    ++vused_;
  }
}

T& Top() 
{
  if( vused_ == 0 )
  {
    throw "empty stack";
  }
  return v_[vused_-1];
}

Посмотри на конструкцию

"v_+vused"

в Stack copy constructor. Посмотри на конструкцию

return v_[vused_-1]