Программирование на С++, индивидуальная работа

class stack {
  private:
     char st[55];   // массив для хранения элементов стека
     int  ptr;      // указатель номера СЕДУЮЩЕГО свободного места в массиве
     int  max_ptr;  // максимальный размер стека
     char buf[110];  // для организации печати информации о состоянии стека
  public:
     stack();            // конструктор
     ~stack();           // деструктор
     void push(char c);  // метод - поместить в стек
     char pop();         // метод - взять из стека ('\0' - если стек пуст)
     char look();        // метод - посмотреть что в вершин стека ('\0' - если стек пуст)
     char * pr();        // метод - вернуть символьную строку - элементов в стеке
     void prln();        // метод -  распечатать стек
};
stack::stack()            // конструктор
     {
      max_ptr=55;
      ptr=0;
      for(int i=0; i< max_ptr; i++) st[i]='\0';
     };
stack::~stack()          // деструктор
     {
      ptr=0;
      for(int i=0; i< max_ptr; i++) st[i]='\0';
     };
void stack::push(char c)   // метод - поместить в стек
     {
      if ((ptr+1) > max_ptr) 
      { printf("*** переполнение стека ***\n");
        exit(666);
      };
      st[ptr++]=c;
      return;
     };
char stack::pop()    // метод - взять из стека ('\0' - если стек пуст)
    {
      char cc;
      if (ptr < 0) return '\0';
      ptr--;
      cc=st[ptr];
      st[ptr]='\0';
      return cc;
    };
 
char stack::look()      // метод - посмотреть что в вершин стека ('\0' - если стек пуст)
    {
     char cc;
     int t_ptr;
     t_ptr=ptr-1;
     if (t_ptr < 0) return '\0';
     cc = st[t_ptr];
     return cc;
    };
 
char *stack::pr()  // метод - вернуть символьную строку - элементов в стеке
    { int i;
      int j=0;
      buf[j++]=':'; buf[j++]=' ';
      for (i= (strlen(st)-1); i >= 0;  i--) 
       {      
         buf[j++]=st[i];
         buf[j++]=' ';
       };
      buf[--j]='\0';
      //sprintf(buf,": %s ",st);
      return buf;
    };
 
void stack::prln()    // метод -  распечатать стек
    { printf("%s\n", pr());
      return;
    };
=====================================================================
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//#include "stack.h"
int main(int argc, char * argv[]) {
  stack st; 
  st.prln();
 
  st.push('1'); st.prln();
  st.push('2'); st.prln();
  st.push('3'); st.prln();
  st.push('4'); st.prln();
  char
  z=st.pop();
  printf("===>pop ===> %c \n",z);
  st.prln();
  z=st.pop();
  printf("===>pop ===> %c \n",z);
  st.prln();
  z=st.look();
  printf("===>look===> %c \n",z);
  st.prln();
  printf("*********** %s\n",st.pr());
 return;
};

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
class st {
   private:
   int l;           // длина
   char * s;        // адрес строки
  public:
   st();            // конструктор без параметра
   st(char *);    // конструктор с инициализирующим параметром
   ~st();
const char * put(const char *); // взять указатель на строку
const char * get();               // записать строку
 st(const st & x);                // конструктор копирования
 st & operator=(const st & x);    // оператор присваивания
 st & operator+=(const st & x);  //унарный оператор +=
 
 friend st operator+(const st & x, const st & y); 
 // дружественная функция +
 
 friend st operator-(const st & x, const st & y);
                            // дружественная функция -
 
 void ch(char); // для теста - изменить 0-й символ
 void pr(char *); // для теста - распечатать....
 
};
 
void st::ch(char x)
{ if (s[0] != '\0') this->s[0]=x;
   return;
};
 
 void st::pr(char tit[]="")
{printf("%s[%d]<%s>\n",tit,l,s);return; };
 
st::st()
{ l=1; s=new char[1]; s[0]='\0';};  
 
st::st(char * d)
{ l=strlen(d)+1; s=new char[l]; 
  strcpy(s, d);
  };
 
st::~st()
{
   delete [] s;
   l=0;
};
 
 st & st::operator=(const st & x)
 {
   if(this == &x) return *this;
   delete [] this->s;
   this->l=x.l;
   this->s=new char[l]; 
   strcpy(s, x.s); 
   return *this;
 };
 
 // copy constructor
 //   попробуйте убрать.....
 st::st(const st & x)
 {
   this->l=x.l;
   this->s=new char[l]; 
   strcpy(s, x.s); 
 };
 
 // унарный +=
 st & st::operator+=(const st & x)
 {
   char *p;    int lp=this->l+x.l-1;
   p=new char[lp];
   sprintf(p,"%s%s",this->s, x.s);
   // в р - конактенитрованная строка
   delete [] this->s;
   this->l=lp;
   this->s=new char[lp]; 
   strcpy(this->s, p); 
   return *this;
 };
 // бинарный +
 st operator+(const st & x, const st & y)
 {
   char *p; 
   st temp;//! вызывается конструктор копирования
   int lp=x.l + y.l -1;
 
   p=new char[lp];
 
   sprintf(p,"%s%s", x.s, y.s);
   // в р - конактенитрованная строка
   temp.l=lp;
   temp.s=new char[lp]; 
   strcpy(temp.s, p); 
   return temp;
 };
 
 // бинарный -
 st operator-(const st & x, const st & y)
 {
   printf("x=%s  y=%s \n", x.s, y.s); 
   char *p; 
   st temp;  // !!!!!!!!!!!!!!!!!!!!!
   int i,j;    
   int k;
   char tchar;
   int flag;
   int n=x.l+1;
   p=new char[n];
   k=0;
   for(i=0; i< x.l; i++)
    {   tchar=x.s[i];
        // есть ли tchar в y.s ?
        flag=0;
        for(j=0;j<y.l;j++)  
          if(tchar==y.s[j]) {flag=1; break;};
        if(flag==0) p[k++]=tchar;
    };
    p[k]='\0';
   // в р - новая строка
   temp.l=k;
   temp.s=new char[k]; 
   strcpy(temp.s, p); 
   return temp;
 };
 
const char * st::put(const char * d)
{ 
  delete [] s;
  l=strlen(d)+1; s=new char[l]; 
  strcpy(s, d); 
  return s;
};
 
const char * st::get()
{
  return s;
}
 
int main(int argc, char *argv[])
{ st a1, a2, a3, a4="куку";
  const char * p;
 
  p=a1.put("привет");  
  printf("***p===<%s>\n",p);
  a1.pr("a1= ....  ==> ");
  a2=a1;
  a2.pr("a2=a1 => ");
  a3.put("Всем "); a3.pr("a3.put(...) ==> ");
  a3+=a2;        a3.pr("a3+=a2 ==> ");
  printf("*************************\n");
  a1.ch('$');      a1.pr("a1($) ==> ");
  a2=a1;
  a2.ch('@');    a2.pr("a1(@) ==> ");
  a4.pr("a4 ==> ");
  printf("*************************\n");
  a2=a1 + " +++ " + a4;    a2.pr("a1 +++ a4 ==> ");
  a1 = "победа!";   a1.pr("a1=.... ==> ");
  a2 = a1 - "по";   a2.pr("a2=a1 - по ==> ");
  a3 = a1 - "ап";   a3.pr("a3=a1 - ап ==> ");
  return 0;
}

***p===<привет>
a1= ....  ==> [7]<привет>
a2=a1 => [7]<привет>
a3.put(...) ==> [6]<Всем >
a3+=a2 ==> [12]<Всем привет>
*************************
a1($) ==> [7]<$ривет>
a1(@) ==> [7]<@ривет>
a4 ==> [5]<куку>
*************************
a1 +++ a4 ==> [16]<$ривет +++ куку>
a1=.... ==> [8]<победа!>
x=победа!  y=по
a2=a1 - по ==> [5]<беда!>
x=победа!  y=ап
a3=a1 - ап ==> [5]<обед!>

#include <stdio.h>
#include <iostream.h>
#include <string.h>
#include <stdlib.h>

class set {
private:
int size;
int *elems;
public:
set(void);
friend set operator+(set,set);
friend set operator-(set,set);
friend set operator*(set,set);
friend int operator<=(set,set);
friend int operator>=(set,set);
friend int operator==(set,set);
friend int operator!=(set,set);
friend void operator>>(set,char*); //Вывод множества в файл
friend void operator << (set&,char*); //Ввод множества из файла
void Print();
};

class ErrorInOpenFile {
public:
ErrorInOpenFile() { strcpy(mess,"Ошибка при работе с файлом");}
void ErrMessage() const {std::cout << mess;}
private:
char mess[50];
};

set::set() // конструктор
{
size=0;
};

int operator != (set a, set b) // не равно
{
int i,j,flg,res;
res=1;
for(i=0; i<a.size; i++)
{
flg=0;
for(j=0; j<b.size; j++)
if(b.elems[j] == a.elems[i]) flg=1;
if(!flg) res=0;
}
return !res;
};

int operator == (set a, set b) // равно
{
int i,j,flg,res;
res=1;
for(i=0;i<a.size;i++)
{
flg=0;
for(j=0; j<b.size; j++)
if(b.elems[j] == a.elems[i]) flg=1;
if(!flg) res=0;
}
return res;
};

int operator>=(set a, set b) {
int i,j;
int res,flg;
res=1;
for(i=0; i < a.size; i++) {
flg=0;
for(j=0; j<b.size; j++)
if(b.elems[j] == a.elems[i]) flg=1;
if(!flg) res=0;
}
return res;
};

int operator <= (set a, set b)
{
int i,j;
int res,flg;
res=1;
for(i=0; i<b.size; i++)
{
flg=0;
for(j=0;j<a.size;j++)
if(a.elems[j] == b.elems[i]) flg=1;
if(!flg)res=0;
}
return res;
};

set operator + (set a,set b)
{
int i,j,k;
int count;
count=0;
int flag;
for(i=0;i<b.size;i++)
{
flag=1;
for(j=0;j<a.size;j++)
if(a.elems[j] == b.elems[i]) flag=0;
if(flag) count++;
}
count+=a.size;
set res;
res.size=count;
res.elems=new int[count];
for(i=0;i<a.size;i++)res.elems[i]=a.elems[i];
for(j=0;j<b.size;j++)
{
flag=1;
for(k=0;k<a.size;k++)
if(a.elems[k]==b.elems[j])flag=0;
if(flag) res.elems[i++]=b.elems[j];
}
return res;
};

set operator-(set a,set b)
{
int i,j,k;
int count;
count=0;
int flag;
for(i=0;i<a.size;i++)
{
flag=1;
for(j=0;j<b.size;j++)
if(a.elems[i]==b.elems[j])flag=0;
if(flag)count++;
}
set res;
res.size=count;
res.elems=new int[count];
i=0;
for(j=0;j<a.size;j++)
{
flag=1;
for(k=0;k<b.size;k++)
if(a.elems[j]==b.elems[k])flag=0;
if(flag) res.elems[i++]=a.elems[j];
}

return res;
};

set operator*(set a,set b)
{
int i,j,k;
int count;
count=0;
int flag;
for(i=0;i<b.size;i++)
{
flag=1;
for(j=0;j<a.size;j++)
if(a.elems[j]==b.elems[i])flag=0;
if(!flag)count++;
}
set res;
res.size=count;
res.elems=new int[count];
i=0;
for(j=0;j<b.size;j++)
{
flag=1;
for(k=0;k<a.size;k++)
if(a.elems[k]==b.elems[j])flag=0;
if(!flag) res.elems[i++]=b.elems[j];
}
return res;
};

void operator << (set& nw,char* FileName)
{
const MAX_STR=255;
FILE *in;
char buff[MAX_STR+1];
try
{
in=fopen(FileName,"r");
if(in==NULL) throw ErrorInOpenFile();
}
catch(ErrorInOpenFile ERR)
{
ERR.ErrMessage();
exit(1);
}
unsigned i,count;
fgets(buff,MAX_STR,in);
sscanf(buff,"%d",&count);
nw.size=count;
nw.elems=new int[count];
for(i=0;i<count;i++)
{
fgets(buff,MAX_STR,in);
sscanf(buff,"%d",&nw.elems[i]);
}
fclose(in);
};

void operator>>(set nw,char* FileName)
{
int i;
const MAX_STR=255;
char buff[MAX_STR];
FILE* out;
try
{
out=fopen(FileName,"w+");
if(out==NULL)throw ErrorInOpenFile();
}
catch(ErrorInOpenFile ERR)
{
ERR.ErrMessage();
exit(1);
}
sprintf(buff,"%d\n",nw.size);
fputs(buff,out);
for(i=0; i<nw.size; i++)
{
sprintf(buff,"%d\n",nw.elems[i]);
fputs(buff,out);
}
fclose(out);
};

void set::Print()
{
int i;
std::cout << "\n";
for(i=0;i<size;i++)
std::cout << elems[i] << "\n";
};
int main()
{
set A;
set B;
set C;
A << "SetA.txt";
std::cout << "\nSet A";
A.Print();
B << "SetB.txt";

std::cout << "\nSet B";
B.Print();

C=A+B;
std::cout << "\nSet C";
C.Print();
// set D;
// D << "SetD.txt";
// set E;
// E=A-D;
// std::cout << "\nSet E";
// E.Print();
// set F;
// F=A*D;
// std::cout << "\nSet F";
// F.Print();
  return 0;
};

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
 
class string {
 private:
     char *str;
     unsigned char attr;
     int  row, col;
 public:
     string();
     string(char *, unsigned char, int , int);
     void write();
};
string::string()
  {
   str = new char [sizeof "Привет!"];
   strcpy(str, "Привет!");
   attr=(BLUE << 4) + YELLOW;  // BROWN << 4+GREEN;
   row=15;
   col=36;
  };
string::string(char * line, unsigned char a, int y=0, int x=0)
 {
  str=new char [strlen(line)+1];
  strcpy(str, line);
   attr=a;
   row=y;
   col=x;
  };
void string::write()
{
   textattr(attr);
   gotoxy(col, row);
   cputs(str);
}

int main(int argc, char * argv[])
{
   clrscr();
 
   std::string string1;
   std::string string2("Строка вторая!", (BLACK << 4)+WHITE);
   std::string string3("Третья строка!", (BROWN << 4)+GREEN, 17, 19);
   std::string string4("Четвертая строка!", (BROWN << 4)+GREEN, 1, 1);
   string1.write();
   string2.write();
   string3.write();
   string4.write();
   return 0;
}