home *** CD-ROM | disk | FTP | other *** search
/ PC Extra Super CD 1998 January / PCPLUS131.iso / INTROCPP / PROG5-1.CPP next >
Encoding:
C/C++ Source or Header  |  1997-12-01  |  4.3 KB  |  180 lines
  1. /*
  2.    prog5-?.cpp
  3.  
  4.    En enkel strängklass som demonstrerar överlagrade operatorer
  5.  
  6.    Klassen cstring (inte string, för att undvika konflikt med  
  7.    eventuella strängklasser i kompilatorns bibliotek) inkapslar
  8.    vanliga teckensträngar och tar hand om den allokering och de-
  9.    allokering av minne som krävs. Operatorer för tilldelning,
  10.    åtkomst av enskilda tecken, jämförelse och sammanslagning har
  11.    överlagrats.  
  12.    För att inte krångla till exemplet kopieras strängdata alltid,
  13.    och inga felkontroller görs. Jämförelse av strängar sker med
  14.    strcmp, vilket kan ge oväntat resultat (tex för strängar inne-
  15.    hållande å, ä och ö). 
  16.  
  17. */
  18.  
  19. #include <stdio.h>
  20. #include <string.h>   // <-- behövs för standardsträngfunktionerna
  21.  
  22. class cstring
  23. {
  24.    private:
  25.  
  26.      // pekare till strängen
  27.      char* ptr;
  28.  
  29.    public:
  30.  
  31.      // förvald konstruktor
  32.      cstring() { ptr = 0; }
  33.  
  34.      // konstruktor för initiering med strängpekare
  35.      cstring(const char*);
  36.  
  37.      // kopieringskonstruktor
  38.      cstring(const cstring&);
  39.  
  40.      // destruktor
  41.      ~cstring();
  42.  
  43.      // skriv ut strängen
  44.      void print() { printf("\"%s\"",ptr); }
  45.  
  46.      // överlagrade tilldelningsoperatorer
  47.      cstring& operator=(const char*);
  48.      cstring& operator=(const cstring&);
  49.  
  50.      // överlagrade operatorer för åtkomst till vektorelement
  51.      // notera att vi kan överlagra medlemmar som är const
  52.      // respektive icke-const
  53.      char& operator[](int i)
  54.         { return ptr[i]; }
  55.      const char& operator[](int i) const 
  56.         { return ptr[i]; }
  57.  
  58.      // överlagrade relationsoperatorer
  59.      int operator==(const char* s) const
  60.         { return strcmp(ptr,s) == 0; }
  61.      int operator==(const cstring& s) const
  62.         { return strcmp(ptr,s.ptr) == 0; }
  63.      int operator!=(const char* s) const
  64.         { return strcmp(ptr,s) != 0; }
  65.      int operator!=(const cstring& s) const
  66.         { return strcmp(ptr,s.ptr) != 0; }
  67.      int operator<(const char* s) const
  68.         { return strcmp(ptr,s) < 0; }
  69.      int operator<(const cstring& s) const
  70.         { return strcmp(ptr,s.ptr) < 0; }
  71.      int operator>(const char* s) const
  72.         { return strcmp(ptr,s) > 0; }
  73.      int operator>(const cstring& s) const
  74.         { return strcmp(ptr,s.ptr) > 0; }
  75.      int operator<=(const char* s) const
  76.         { return strcmp(ptr,s) <= 0; }
  77.      int operator<=(const cstring& s) const
  78.         { return strcmp(ptr,s.ptr) <= 0; }
  79.      int operator>=(const char* s) const
  80.         { return strcmp(ptr,s) >= 0; }
  81.      int operator>=(const cstring& s) const
  82.         { return strcmp(ptr,s.ptr) >= 0; }
  83.  
  84.      // överlagrad additionsoperator 
  85.      friend cstring operator+(const cstring& s1,const cstring& s2);
  86. };
  87.  
  88. cstring::cstring(const char* s)
  89. {
  90.    ptr = new char[strlen(s)+1];
  91.    strcpy(ptr,s);
  92. }
  93.  
  94. cstring::cstring(const cstring& s)
  95. {
  96.    ptr = new char[strlen(s.ptr)+1];
  97.    strcpy(ptr,s.ptr);
  98. }
  99.  
  100. cstring::~cstring()
  101. {
  102.    if(ptr)
  103.    {
  104.       delete[] ptr;
  105.    }
  106. }
  107.  
  108. cstring& cstring::operator=(const char* s)
  109. {
  110.    if(ptr)
  111.    {
  112.       delete[] ptr;
  113.    }
  114.    ptr = new char[strlen(s)+1];
  115.    strcpy(ptr,s);
  116.    return *this;
  117. }
  118.  
  119. cstring& cstring::operator=(const cstring& s)
  120. {
  121.    if(ptr)
  122.    {
  123.       delete[] ptr;
  124.    }
  125.    ptr = new char[strlen(s.ptr)+1];
  126.    strcpy(ptr,s.ptr);
  127.    return *this;
  128. }
  129.  
  130. // Överlagrad additionsoperator - lägger ihop två strängar.
  131. // Notera att denna operator inte är medlem i cstring, bara
  132. // en vän till klassen.
  133. cstring operator+(const cstring& s1,const cstring& s2)
  134. {
  135.    cstring s;
  136.  
  137.    s.ptr = new char[strlen(s1.ptr)+strlen(s2.ptr)+1];
  138.    strcpy(s.ptr,s1.ptr);
  139.    strcat(s.ptr,s2.ptr);
  140.    return s;
  141. } 
  142.  
  143. // testa strängklassen
  144. main()
  145. {
  146.    // initiering
  147.    cstring s  = "musselsoppa";
  148.    cstring s2 = s;
  149.    cstring s3 = s + ", tack!";
  150.    cstring s4;
  151.  
  152.    // tilldelning och addition
  153.    s4 = s2 + "ns at" + "tack!";
  154.  
  155.    // utskrift
  156.    printf("s  = "); s.print(); 
  157.    printf("\ns2 = "); s2.print(); 
  158.    printf("\ns3 = "); s3.print(); 
  159.    printf("\ns4 = "); s4.print(); 
  160.  
  161.    // jämförelse
  162.    if(s == s2)
  163.    {
  164.       printf("\ns == s2\n");
  165.    }
  166.    if(s2 != s3)
  167.    {
  168.       printf("s2 != s3\n");
  169.    }
  170.    if(s3 < s4)
  171.    {
  172.       printf("s3 < s4\n");
  173.    }
  174.  
  175.    // åtkomst till enskilda tecken
  176.    printf("s[1] = '%c'\n",s[1]);
  177.  
  178.    return 0;
  179. }
  180.