Proszę o pomoc. Łańcuch znaków-zliczanie odwołań.C++

Question

Czy jest ktoś w stanie dopisać do tego kodu nastepujące funkcje:

 int rcstring::atoi() - konwersja łańcucha znaków na liczbę;

rcstring& rcstring::toLower() - konwersja wielkich liter na małe;

rcstring rcstring::Left(int n) - ekstrakcja n znaków od lewej.

Wiem, że nie powinno się prośić na tym forum o gotowe rozwiązania , a o pomoc w zrozumieniu zagadnień by samemu do czegoś dojść. Ale prosze o wyrozumiałość, sprawa jest naprawdę pilna i wymaga po prostu kodu.

Z góry przepraszam za takie prośby i dziękuję każdemu kto zechciał pomóc.
 

#ifndef __RCSTRING_H__
#define __RCSTRING_H__
#include <string.h>
#include <stdio.h>
#include <malloc.h>
#include <iostream>
using namespace std;

class rcstring{
  struct rctext;
  rctext* data;
public:
class Range{};
rcstring();
rcstring(const char*);
rcstring(const rcstring&);
~rcstring();
rcstring& operator=(const char*);
rcstring& operator=(const rcstring&);
rcstring& operator+=(const rcstring &);
rcstring operator+(const rcstring &) const;
friend ostream& operator<<(ostream&, const rcstring&);
void check (unsigned int i) const;
char read(unsigned int i) const;
void write(unsigned int i, char c);

char operator[](unsigned int i) const;
char& operator[](unsigned int i);
};

struct rcstring::rctext
{
  char* s;
  unsigned int size;
  unsigned int n;

  rctext(unsigned int nsize, const char* p)
  {
    n=1;
    size=nsize;
    s=new char[size+1];
    strncpy(s,p,size);
    s[size]='\0';
  };
  ~rctext()
  {
    delete [] s;
  };
  rctext* detach()
  {
    if(n==1)
      return this;
    rctext* t=new rctext(size, s);
    n--;
    return t;
  };
  void assign(unsigned int nsize, const char *p)
  {
    if(size!=nsize)
    {
      char* ns=new char[nsize+1];
      size = nsize;
      strncpy(ns,p,size);
      delete [] s;
      s = ns;
    }
    else
      strncpy(s,p,size);
    s[size]='\0';
  }
private:
  rctext(const rctext&);
  rctext& operator=(const rctext&);
};

inline rcstring::rcstring()
  {
    data = new rctext(0,"");
  }

inline rcstring::rcstring(const rcstring& x)
  {
    x.data->n++;
    data=x.data;
  }
inline rcstring::~rcstring()
{
  if(--data->n==0)
    delete data;
}

rcstring& rcstring::operator=(const rcstring & x)
{
  x.data->n++;
  if(--data->n == 0)
    delete data;
  data=x.data;
  return *this;
}

rcstring::rcstring(const char* s)
{
 data=new rctext(strlen(s),s);
}

rcstring& rcstring::operator=(const char* s)
{
  if(data->n==1)
    data->assign(strlen(s),s);
  else
  {
    rctext* t = new rctext(strlen(s),s);
    data->n--;
    data= t;
  };
  return *this;
}

ostream& operator << (ostream& o, const rcstring& s)
{
  return o<<s.data->s;
}

rcstring& rcstring::operator+=(const rcstring & s)
{
unsigned int newsize=data->size+s.data->size;
rctext *newdata=new rctext(newsize,data->s);
strcat(newdata->s,s.data->s);
if(--data->n==0)
  delete data;
data = newdata;
return *this;
}

rcstring rcstring::operator+(const rcstring & s) const
{
  return rcstring(*this)+=s;
}

inline void rcstring::check (unsigned int i) const
{
if(data->size<=i)
  throw Range();
}

inline char rcstring::read(unsigned int i) const
{
 return data->s[i];
}

inline void rcstring::write(unsigned int i, char c)
{
  data = data->detach();
  data->s[i] = c;
}

char rcstring::operator[](unsigned int i) const
{
  cout << "char rcstring::operator[](unsigned int i) const"<<endl;
  check(i);
  return data->s[i];
}

char& rcstring::operator[](unsigned int i)
{
  cout << "char& rcstring::operator[](unsigned int i)"<<endl;
  check(i);
  data = data->detach();
  return data->s[i];
}

#endif /* __RCSTRING_H__ */

 

Answer 1

Nie dostaniesz rozwiązania (ale kumple z roku na pewno wymienią się za pieniądze), mogę dać ci jedynie wskazówki:

Zakładam, że te funkcje masz zrobić w jakiś "sprytny" sposób, a nie przez wykorzystanie innych funkcji, które są zamiennikami dla tych, których implementacje masz zrobić. Więc:

1. Mówiąc szczerze nie mam pojęcia, ja bym skorzystał najpewniej z stringstream, ale w twoim wypadku użycie tego chyba jest nielegalne.
2. Stringa przechowujesz w tablicy char'a, każdą wartość char'a można zrzutować na int => kod ASCII, wystarczy że będziesz sprawdzał każdą literę czy znajduje się w przedziale małych liter kodu ASCII, jeżeli tak to powiększysz ją o różnicę w kodzie ASCII dużych i małych znaków.
3. Czyli, że co? Jak to ma wyglądać? Tworzysz nowy rstring zaczynający się na pozycji 0 i posiadający n znaków? Przecież to jest proste i nie wymaga nawet wskazówki.