namespace cpp

C++ lernen, kennen, anwenden

Benutzer-Werkzeuge

Webseiten-Werkzeuge


anwenden:sequence

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

Link zu dieser Vergleichsansicht

anwenden:sequence [2016-12-28 12:40]
127.0.0.1 Externe Bearbeitung
anwenden:sequence [2020-07-26 18:31] (aktuell)
rrichter
Zeile 26: Zeile 26:
 { {
 public: public:
-  SequenceError(const char* message) : msg(message) {} +  SequenceError(char const* message) : msg(message) {} 
-  virtual const char* what() const { return msg; }+  virtual char const* what() const { return msg; }
 private: private:
-  const char* msg;+  char const* msg;
 }; };
  
Zeile 55: Zeile 55:
   {   {
     int use;       // reference count     int use;       // reference count
-    const T value;+    T const value;
     Item* next;     Item* next;
  
Zeile 69: Zeile 69:
  
 <code cpp> <code cpp>
-    Item(const T& x, Item* successor)+    Item(T const& x, Item* successor)
     : use(1), value(x), next(successor)     : use(1), value(x), next(successor)
     {     {
Zeile 94: Zeile 94:
  
 <code cpp> <code cpp>
-  Sequence(const T& headvalue, const Sequence& tailseq) +  Sequence(T const& headvalue, Sequence const& tailseq) 
   : item(new Item(headvalue, tailseq.item))    : item(new Item(headvalue, tailseq.item)) 
   {}   {}
Zeile 103: Zeile 103:
  
 <code cpp> <code cpp>
-  Sequence(const Sequence& original)+  Sequence(Sequence const& original)
   : item(original.item)   : item(original.item)
   {   {
Zeile 155: Zeile 155:
   ~Sequence() { destroy(item); }     ~Sequence() { destroy(item); }  
  
-  Sequence& operator=(const Sequence& original) +  Sequence& operator=(Sequence const& original) 
   {   {
     if (original.item) original.item->use++;     if (original.item) original.item->use++;
Zeile 218: Zeile 218:
   public:   public:
     Init(Item* lastnode) : item(lastnode) {}     Init(Item* lastnode) : item(lastnode) {}
-    Init operator,(const T& x) +    Init operator,(T const& x) 
     {     {
       item->next = new Item(x, 0);       item->next = new Item(x, 0);
Zeile 232: Zeile 232:
  
 <code cpp> <code cpp>
-  Init operator=(const T& x)+  Init operator=(T const& x)
   {   {
     destroy(item);     destroy(item);
Zeile 274: Zeile 274:
 template <class T> template <class T>
 inline inline
-bool empty(const Sequence<T>& s) // Lisp: null?+bool empty(Sequence const<T>& s) // Lisp: null?
 { {
   return s.empty();   return s.empty();
Zeile 281: Zeile 281:
 template <class T> template <class T>
 inline inline
-T head(const Sequence<T>& s) // Lisp: car+T head(Sequence const<T>& s) // Lisp: car
 { {
   return s.head();   return s.head();
Zeile 288: Zeile 288:
 template <class T> template <class T>
 inline inline
-Sequence<T> tail(const Sequence<T>& s) // Lisp: cdr+Sequence<T> tail(Sequence const<T>& s) // Lisp: cdr
 { {
   return s.tail();   return s.tail();
Zeile 296: Zeile 296:
 inline inline
 Sequence<T>  Sequence<T> 
-concat(const T& x, const Sequence<T>& s) // Lisp: cons+concat(T const& x, Sequence const<T>& s) // Lisp: cons
 { {
   return Sequence<T>(x, s);   return Sequence<T>(x, s);
Zeile 303: Zeile 303:
 template <class T>                       // Lisp: template <class T>                       // Lisp:
 Sequence<T>  Sequence<T> 
-concat(Sequence<T> s, const T& x)       // (define append  +concat(Sequence<T> s, T const& x)       // (define append  
 {                                       //   (lambda s x) {                                       //   (lambda s x)
   if (empty(s))                         //   (if (null? s)   if (empty(s))                         //   (if (null? s)
anwenden/sequence.txt · Zuletzt geändert: 2020-07-26 18:31 von rrichter