Array.h 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823
  1. #ifndef Array_H
  2. #define Array_H
  3. #include "Betriebssystem.h"
  4. #include <stdexcept>
  5. #include "Text.h"
  6. namespace Framework
  7. {
  8. template< class TYP >
  9. // Ein Eintrag in einer Linked List
  10. struct ArrayEintrag
  11. {
  12. TYP var;
  13. bool set = false;
  14. ArrayEintrag< TYP > *next = 0;
  15. // Setzt den Eintrag auf die Werte des anderen Eintrages
  16. ArrayEintrag &operator=( ArrayEintrag &r )
  17. {
  18. var = r.var;
  19. set = r.set;
  20. next = r.next;
  21. return *this;
  22. }
  23. // Gibt den aktuell gespeicherten Wert zurück
  24. operator TYP()
  25. {
  26. if( !set )
  27. {
  28. Text err = "Index out of Range Exception File: ";
  29. err += __FILE__;
  30. err += " Line: ";
  31. err += __LINE__;
  32. throw std::out_of_range( (char*)err );
  33. }
  34. return var;
  35. }
  36. // inkrementiert durch die Linked List durch
  37. ArrayEintrag< TYP > &operator++() // prefix
  38. {
  39. if( !next )
  40. {
  41. ArrayEintrag<TYP> tmp;
  42. tmp.set = 0;
  43. tmp.next = 0;
  44. *this = tmp;
  45. return *this;
  46. }
  47. *this = *next;
  48. return *next;
  49. }
  50. // inkrementiert durch die Linked List durch
  51. ArrayEintrag< TYP > &operator++( int ) // postfix
  52. {
  53. if( !next )
  54. {
  55. ArrayEintrag<TYP> tmp;
  56. tmp.set = 0;
  57. tmp.next = 0;
  58. *this = tmp;
  59. return *this;
  60. }
  61. *this = *next;
  62. return *next;
  63. }
  64. };
  65. template< class TYP >
  66. class Iterator
  67. {
  68. private:
  69. ArrayEintrag< TYP > *current;
  70. public:
  71. Iterator( ArrayEintrag< TYP > *start )
  72. {
  73. current = start;
  74. while( current && !current->set )
  75. {
  76. current = current->next;
  77. }
  78. }
  79. Iterator( const Iterator &it )
  80. {
  81. current = it.current;
  82. }
  83. Iterator< TYP > &operator=( Iterator< TYP > &r )
  84. {
  85. current = r.current;
  86. return *this;
  87. }
  88. bool hasNext()
  89. {
  90. ArrayEintrag< TYP > *next = current->next;
  91. while( next && !next->set )
  92. {
  93. next = next->next;
  94. }
  95. return next != 0;
  96. }
  97. Iterator< TYP > next()
  98. {
  99. if( !current )
  100. {
  101. Text err = "Index out of Range Exception File: ";
  102. err += __FILE__;
  103. err += " Line: ";
  104. err += __LINE__;
  105. throw std::out_of_range( (char*)err );
  106. }
  107. return Iterator( current->next );
  108. }
  109. operator bool()
  110. {
  111. return current != 0;
  112. }
  113. operator TYP()
  114. {
  115. if( !current || !current->set )
  116. {
  117. Text err = "Index out of Range Exception File: ";
  118. err += __FILE__;
  119. err += " Line: ";
  120. err += __LINE__;
  121. throw std::out_of_range( (char*)err );
  122. }
  123. return current->var;
  124. }
  125. Iterator< TYP > &operator++() // prefix
  126. {
  127. Iterator< TYP > temp( *this );
  128. do
  129. {
  130. if( current )
  131. current = current->next;
  132. } while( current && !current->set );
  133. return temp;
  134. }
  135. Iterator< TYP > &operator++( int ) // postfix
  136. {
  137. do
  138. {
  139. if( current )
  140. current = current->next;
  141. } while( current && !current->set );
  142. return *this;
  143. }
  144. TYP operator->()
  145. {
  146. if( !current || !current->set )
  147. {
  148. Text err = "Index out of Range Exception File: ";
  149. err += __FILE__;
  150. err += " Line: ";
  151. err += __LINE__;
  152. throw std::out_of_range( (char*)err );
  153. }
  154. return current->var;
  155. }
  156. TYP val()
  157. {
  158. if( !current || !current->set )
  159. {
  160. Text err = "Index out of Range Exception File: ";
  161. err += __FILE__;
  162. err += " Line: ";
  163. err += __LINE__;
  164. throw std::out_of_range( (char*)err );
  165. }
  166. return current->var;
  167. }
  168. };
  169. #define _ val()
  170. template< class TYP >
  171. // Eine Linked List von Klassen, die kein Reference Counting berteiben
  172. class Array
  173. {
  174. private:
  175. ArrayEintrag< TYP > *entries;
  176. int ref;
  177. public:
  178. // Erstellt eine neue Linked List
  179. Array() noexcept
  180. {
  181. entries = new ArrayEintrag< TYP >();
  182. entries->set = 0;
  183. entries->next = 0;
  184. ref = 1;
  185. }
  186. // Kopiert eine Linked list
  187. Array( const Array &arr )
  188. {
  189. entries = new ArrayEintrag< TYP >();
  190. entries->set = 0;
  191. entries->next = 0;
  192. int anz = arr.getEintragAnzahl();
  193. for( int i = 0; i < anz; i++ )
  194. add( arr.get( i ) );
  195. ref = 1;
  196. }
  197. // Leert und löscht die Linked List
  198. ~Array()
  199. {
  200. leeren();
  201. delete entries;
  202. }
  203. // Hängt ein Element ans Ende der Liste an
  204. // t: Das neue Element
  205. void add( TYP t )
  206. {
  207. for( ArrayEintrag< TYP > *e = entries; 1; e = e->next )
  208. {
  209. if( !e->set && !e->next )
  210. {
  211. e->var = t;
  212. e->set = 1;
  213. break;
  214. }
  215. if( !e->next )
  216. {
  217. e->next = new ArrayEintrag< TYP >();
  218. e->next->set = 0;
  219. e->next->next = 0;
  220. }
  221. }
  222. }
  223. // Fügt ein Element bei einer bestimmten Position in die Liste ein
  224. // t: das neue Element
  225. // i: Die Position, wo das Element eingefügt wird (danach der Index des neuen Elementes)
  226. void add( TYP t, int i )
  227. {
  228. if( i < 0 )
  229. return;
  230. ArrayEintrag< TYP > *e = entries;
  231. for( int a = 0; a < i; ++a )
  232. {
  233. if( !e->next )
  234. {
  235. ArrayEintrag< TYP > *ne = new ArrayEintrag< TYP >();
  236. ne->set = 0;
  237. ne->next = 0;
  238. e->next = ne;
  239. }
  240. e = e->next;
  241. }
  242. ArrayEintrag< TYP > *ne = new ArrayEintrag< TYP >();
  243. ne->var = e->var;
  244. ne->set = e->set;
  245. ne->next = e->next;
  246. e->next = ne;
  247. e->var = t;
  248. e->set = 1;
  249. }
  250. // Setzt den Wert des i-ten Eintrags
  251. // t: der Neue Wert
  252. // i: Der Index des Eintrages der gesetzt werden soll
  253. void set( TYP t, int i )
  254. {
  255. if( i < 0 )
  256. return;
  257. ArrayEintrag< TYP > *e = entries;
  258. for( int a = 0; a < i; ++a )
  259. {
  260. if( !e->next )
  261. {
  262. ArrayEintrag< TYP > *ne = new ArrayEintrag< TYP >();
  263. ne->set = 0;
  264. ne->next = 0;
  265. e->next = ne;
  266. }
  267. e = e->next;
  268. }
  269. e->var = t;
  270. e->set = 1;
  271. }
  272. // Verändert die Position des i-ten Elementes in der Liste
  273. // i: Der Index des Elementes, welches verschoben werden soll
  274. // p: Die Zielposition des Elementes (danach der neue Index des Elementes)
  275. void setPosition( int i, int p )
  276. {
  277. if( i < 0 || p < 0 || i == p )
  278. return;
  279. ArrayEintrag< TYP > *e = entries;
  280. ArrayEintrag< TYP > *ve = 0;
  281. for( int a = 0; a < i; ++a )
  282. {
  283. if( !e->next )
  284. return;
  285. ve = e;
  286. e = e->next;
  287. }
  288. ArrayEintrag< TYP > *e2 = entries == e ? e->next : entries;
  289. ArrayEintrag< TYP > *ve2 = 0;
  290. for( int a = 0; a < p; ++a )
  291. {
  292. if( !e2 )
  293. return;
  294. ve2 = e2;
  295. if( e2->next == e )
  296. e2 = e->next;
  297. else
  298. e2 = e2->next;
  299. }
  300. if( !e )
  301. return;
  302. if( !ve2 )
  303. entries = e;
  304. else
  305. ve2->next = e;
  306. if( ve )
  307. ve->next = e->next;
  308. else
  309. entries = e->next;
  310. e->next = e2;
  311. }
  312. // Löscht ein Bestimmtes Element
  313. // i: Der Index des Elementes das gelöscht werden soll
  314. void remove( int i )
  315. {
  316. if( i < 0 )
  317. return;
  318. ArrayEintrag< TYP > *e = entries;
  319. for( int a = 0; a < i; ++a )
  320. {
  321. if( !e->next )
  322. return;
  323. e = e->next;
  324. }
  325. if( !e )
  326. return;
  327. if( e->next )
  328. {
  329. e->var = e->next->var;
  330. e->set = e->next->set;
  331. }
  332. else
  333. e->set = 0;
  334. ArrayEintrag< TYP > *del = e->next;
  335. if( e->next )
  336. e->next = e->next->next;
  337. else
  338. e->next = 0;
  339. if( del )
  340. {
  341. del->set = 0;
  342. del->next = 0;
  343. delete del;
  344. }
  345. }
  346. // Vertauscht zwei Elemente in der Liste
  347. // vi: Der Index des ersten Elementes
  348. // ni: Der Index des zweiten Elementes
  349. void tausch( int vi, int ni )
  350. {
  351. if( vi < 0 || ni < 0 )
  352. return;
  353. TYP tmp = get( ni );
  354. set( get( vi ), ni );
  355. set( tmp, vi );
  356. }
  357. // Löscht alle Elemente der Liste
  358. void leeren()
  359. {
  360. ArrayEintrag< TYP > *e2 = 0;
  361. for( ArrayEintrag< TYP > *e = entries; e; e = e->next )
  362. {
  363. delete e2;
  364. e2 = e;
  365. }
  366. delete e2;
  367. entries = new ArrayEintrag< TYP >();
  368. entries->set = 0;
  369. entries->next = 0;
  370. }
  371. // Gibt einen Iterator zurück.
  372. // Mit ++ kann durch die Liste iteriert werden
  373. Iterator< TYP > getIterator() const
  374. {
  375. return Iterator< TYP >( entries );
  376. }
  377. // Gibt zurück, wie viele Elemente in der Liste sind
  378. int getEintragAnzahl() const
  379. {
  380. int i = 0;
  381. for( auto it = getIterator(); it; it++ )
  382. ++i;
  383. return i;
  384. }
  385. // Gibt den Wert des i-ten Elementes zurück
  386. // i: Der index des gesuchten Elementes
  387. // throws:
  388. // std::out_of_range wenn i < 0 oder i >= getEintragAnzahl()
  389. TYP get( int i ) const
  390. {
  391. if( i < 0 )
  392. {
  393. Text err = "Index out of Range Exception File: ";
  394. err += __FILE__;
  395. err += " Line: ";
  396. err += __LINE__;
  397. err += " Index: ";
  398. err += i;
  399. throw std::out_of_range( (char*)err );
  400. }
  401. ArrayEintrag< TYP > *e = entries;
  402. for( int a = 0; a < i && e; ++a )
  403. e = e->next;
  404. if( e && e->set )
  405. return e->var;
  406. Text err = "Index out of Range Exception File: ";
  407. err += __FILE__;
  408. err += " Line: ";
  409. err += __LINE__;
  410. err += " Index: ";
  411. err += i;
  412. throw std::out_of_range( (char*)err );
  413. }
  414. // Überprüft, ob ein Element in der Liste enthalten ist
  415. // i: Der Index des gesuchten Elementes
  416. // return: (true), wenn der Index vorhanden ist. (false) sonnst
  417. bool hat( int i ) const
  418. {
  419. if( i < 0 )
  420. return 0;
  421. ArrayEintrag< TYP > *e = entries;
  422. for( int a = 0; a < i && e; ++a )
  423. e = e->next;
  424. if( e && e->set )
  425. return 1;
  426. return 0;
  427. }
  428. // Gibt den Index eines Wertes zurück
  429. // t: Der Wert, nach dem gesucht werden soll
  430. int getWertIndex( TYP t ) const
  431. {
  432. int ret = 0;
  433. for( ArrayEintrag< TYP > *e = entries; e; e = e->next )
  434. {
  435. if( e->set && e->var == t )
  436. return ret;
  437. ++ret;
  438. }
  439. return -1;
  440. }
  441. // Erhöht den Reference Counting Zähler.
  442. // return: this.
  443. Array< TYP > *getThis()
  444. {
  445. ++ref;
  446. return this;
  447. }
  448. // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
  449. // return: 0.
  450. Array< TYP > *release()
  451. {
  452. --ref;
  453. if( !ref )
  454. delete this;
  455. return 0;
  456. }
  457. Array &operator=( const Array &arr )
  458. {
  459. leeren();
  460. int anz = arr.getEintragAnzahl();
  461. for( int i = 0; i < anz; i++ )
  462. add( arr.get( i ) );
  463. return *this;
  464. }
  465. };
  466. template< class TYP >
  467. // Eine Linked List von Zeigern auf Zeichnunge, die Reference Counting berteiben
  468. class RCArray
  469. {
  470. private:
  471. ArrayEintrag< TYP* > *entries;
  472. int ref;
  473. public:
  474. // Erstellt eine neue Linked List
  475. RCArray() noexcept
  476. {
  477. entries = new ArrayEintrag< TYP* >();
  478. entries->set = 0;
  479. entries->next = 0;
  480. ref = 1;
  481. }
  482. // Kopiert eine Linked list
  483. RCArray( const RCArray &arr )
  484. {
  485. entries = new ArrayEintrag< TYP* >();
  486. entries->set = 0;
  487. entries->next = 0;
  488. int anz = arr.getEintragAnzahl();
  489. for( int i = 0; i < anz; i++ )
  490. add( arr.get( i ) );
  491. ref = 1;
  492. }
  493. // Leert und löscht die Linked List
  494. ~RCArray()
  495. {
  496. leeren();
  497. delete entries;
  498. }
  499. // Hängt ein Element ans Ende der Liste an
  500. // t: Das neue Element
  501. void add( TYP* t )
  502. {
  503. for( ArrayEintrag< TYP* > *e = entries; 1; e = e->next )
  504. {
  505. if( !e->set && !e->next )
  506. {
  507. e->var = t;
  508. e->set = 1;
  509. break;
  510. }
  511. if( !e->next )
  512. {
  513. e->next = new ArrayEintrag< TYP* >();
  514. if( e->next->set && e->next->var )
  515. e->next->var->release();
  516. e->next->set = 0;
  517. e->next->next = 0;
  518. }
  519. }
  520. }
  521. // Fügt ein Element bei einer bestimmten Position in die Liste ein
  522. // t: das neue Element
  523. // i: Die Position, wo das Element eingefügt wird (danach der Index des neuen Elementes)
  524. void add( TYP* t, int i )
  525. {
  526. if( i < 0 )
  527. {
  528. if( t )
  529. t->release();
  530. return;
  531. }
  532. ArrayEintrag< TYP* > *e = entries;
  533. for( int a = 0; a < i; ++a )
  534. {
  535. if( !e->next )
  536. {
  537. ArrayEintrag< TYP* > *ne = new ArrayEintrag< TYP* >();
  538. ne->set = 0;
  539. ne->next = 0;
  540. e->next = ne;
  541. }
  542. e = e->next;
  543. }
  544. ArrayEintrag< TYP* > *ne = new ArrayEintrag< TYP* >();
  545. ne->var = e->var;
  546. ne->set = e->set;
  547. ne->next = e->next;
  548. e->next = ne;
  549. e->var = t;
  550. e->set = 1;
  551. }
  552. // Setzt den Wert des i-ten Eintrags
  553. // t: der Neue Wert
  554. // i: Der Index des Eintrages der gesetzt werden soll
  555. void set( TYP* t, int i )
  556. {
  557. if( i < 0 )
  558. {
  559. if( t )
  560. t->release();
  561. return;
  562. }
  563. ArrayEintrag< TYP* > *e = entries;
  564. for( int a = 0; a < i; ++a )
  565. {
  566. if( !e->next )
  567. {
  568. ArrayEintrag< TYP* > *ne = new ArrayEintrag< TYP* >();
  569. ne->set = 0;
  570. ne->next = 0;
  571. e->next = ne;
  572. }
  573. e = e->next;
  574. }
  575. if( e->set && e->var )
  576. e->var->release();
  577. e->var = t;
  578. e->set = 1;
  579. }
  580. // Verändert die Position des i-ten Elementes in der Liste
  581. // i: Der Index des Elementes, welches verschoben werden soll
  582. // p: Die Zielposition des Elementes (danach der neue Index des Elementes)
  583. void setPosition( int i, int p )
  584. {
  585. if( i < 0 || p < 0 || i == p )
  586. return;
  587. ArrayEintrag< TYP* > *ve = 0;
  588. ArrayEintrag< TYP* > *e = entries;
  589. for( int a = 0; a < i; ++a )
  590. {
  591. if( !e->next )
  592. return;
  593. ve = e;
  594. e = e->next;
  595. }
  596. ArrayEintrag< TYP* > *e2 = entries == e ? e->next : entries;
  597. ArrayEintrag< TYP* > *ve2 = 0;
  598. for( int a = 0; a < p; ++a )
  599. {
  600. if( !e2 )
  601. return;
  602. ve2 = e2;
  603. if( e2->next == e )
  604. e2 = e->next;
  605. else
  606. e2 = e2->next;
  607. }
  608. if( !e )
  609. return;
  610. if( !ve2 )
  611. entries = e;
  612. else
  613. ve2->next = e;
  614. if( ve )
  615. ve->next = e->next;
  616. else
  617. entries = e->next;
  618. e->next = e2;
  619. }
  620. // Löscht ein Bestimmtes Element
  621. // i: Der Index des Elementes das gelöscht werden soll
  622. void remove( int i )
  623. {
  624. if( i < 0 )
  625. return;
  626. ArrayEintrag< TYP* > *e = entries;
  627. for( int a = 0; a < i; ++a )
  628. {
  629. if( !e->next )
  630. return;
  631. e = e->next;
  632. }
  633. if( !e )
  634. return;
  635. if( e->next )
  636. {
  637. if( e->set && e->var )
  638. e->var->release();
  639. e->var = e->next->var;
  640. e->set = e->next->set;
  641. }
  642. else
  643. {
  644. if( e->set && e->var )
  645. e->var->release();
  646. e->set = 0;
  647. }
  648. ArrayEintrag< TYP* > *del = e->next;
  649. if( e->next )
  650. e->next = e->next->next;
  651. else
  652. e->next = 0;
  653. if( del )
  654. {
  655. del->set = 0;
  656. del->next = 0;
  657. delete del;
  658. }
  659. }
  660. // Vertauscht zwei Elemente in der Liste
  661. // vi: Der Index des ersten Elementes
  662. // ni: Der Index des zweiten Elementes
  663. void tausch( int vi, int ni )
  664. {
  665. if( vi < 0 || ni < 0 )
  666. return;
  667. TYP* tmp = get( ni );
  668. set( get( vi ), ni );
  669. set( tmp, vi );
  670. }
  671. // Löscht alle Elemente der Liste
  672. void leeren()
  673. {
  674. ArrayEintrag< TYP* > *e2 = 0;
  675. for( ArrayEintrag< TYP* > *e = entries; e; e = e->next )
  676. {
  677. if( e2 && e2->var && e2->set )
  678. e2->var->release();
  679. delete e2;
  680. e2 = e;
  681. }
  682. if( e2 && e2->var && e2->set )
  683. e2->var->release();
  684. delete e2;
  685. entries = new ArrayEintrag< TYP* >();
  686. entries->set = 0;
  687. entries->next = 0;
  688. }
  689. // Gibt einen Iterator zurück.
  690. // Mit ++ kann durch die Liste iteriert werden
  691. Iterator< TYP* > getIterator() const
  692. {
  693. return Iterator< TYP* >( entries );
  694. }
  695. // Gibt zurück, wie viele Elemente in der Liste sind
  696. int getEintragAnzahl() const
  697. {
  698. int i = 0;
  699. for( auto it = getIterator(); it; it++ )
  700. ++i;
  701. return i;
  702. }
  703. // Gibt den Wert des i-ten Elementes zurück mit erhöhtem Reference Counter
  704. // i: Der index des gesuchten Elementes, (0) wenn der Index nicht existiert
  705. TYP *get( int i ) const
  706. {
  707. if( i < 0 )
  708. return (TYP*)0;
  709. ArrayEintrag< TYP* > *e = entries;
  710. for( int a = 0; a < i && e; ++a )
  711. e = e->next;
  712. if( e && e->set && e->var )
  713. return (TYP*)e->var->getThis();
  714. return (TYP*)0;
  715. }
  716. // Gibt den Wert des i-ten Elementes zurück ohne erhöhten Reference Counter
  717. // i: Der index des gesuchten Elementes, (0) wenn der Index nicht existiert
  718. TYP *z( int i ) const // gibt den index - ten T zurück
  719. {
  720. if( i < 0 )
  721. return (TYP*)0;
  722. ArrayEintrag< TYP* > *e = entries;
  723. for( int a = 0; a < i && e; ++a )
  724. e = e->next;
  725. if( e && e->set && e->var )
  726. return (TYP*)e->var;
  727. return (TYP*)0;
  728. }
  729. // Überprüft, ob ein Element in der Liste enthalten ist
  730. // i: Der Index des gesuchten Elementes
  731. // return: (true), wenn der Index vorhanden ist. (false) sonnst
  732. bool hat( int i ) const
  733. {
  734. if( i < 0 )
  735. return 0;
  736. ArrayEintrag< TYP* > *e = entries;
  737. for( int a = 0; a < i && e; ++a )
  738. e = e->next;
  739. if( e && e->set )
  740. return 1;
  741. return 0;
  742. }
  743. // Erhöht den Reference Counting Zähler.
  744. // return: this.
  745. RCArray< TYP > *getThis()
  746. {
  747. ++ref;
  748. return this;
  749. }
  750. // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
  751. // return: 0.
  752. RCArray< TYP > *release()
  753. {
  754. --ref;
  755. if( !ref )
  756. delete this;
  757. return 0;
  758. }
  759. RCArray &operator=( const RCArray &arr )
  760. {
  761. leeren();
  762. int anz = arr.getEintragAnzahl();
  763. for( int i = 0; i < anz; i++ )
  764. add( arr.get( i ) );
  765. return *this;
  766. }
  767. };
  768. }
  769. #endif