radfiz.org.ua

Код: Виділити все

/*

 Визначити клас, який реалізує множину. Визначити методи включення та виключення
 елементу, а також перевантажити операції додавання (об’єднання множин),
 множення (переріз множин), віднімання (різниця множин).
 
*/

#include <iostream>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#define maxn 200
using namespace std;
class Mnojina
 {
      public:
      int Items[maxn];
      int Count;
      public:
             Mnojina () {  Count=0;}
             ~Mnojina () { /*delete Items;*/}
             int IsPresent(int A){
                  for (int i = 0 ; i < Count; i++)
                  {
                      if (*(Items+i)==A) return i+1;
                  }
                  return 0;
             }
             void Include(int A){                 
                  if (!IsPresent(A)){
                     *(Items+Count)=A;
                     Count++;   
                  }
             }
             void Exclude(int A){
                  int n=IsPresent(A);
                  if (n){
                     for (int i = n ; i < Count; i++)
                     {
                        *(Items+i-1)=*(Items+i);
                     }
                     Count--;   
                  }
             }

             void Show(char *name=""){
                  cout<<" Elements of "<<name<<"["<<Count<<"] = { ";
                  for (int i = 0 ; i < Count-1; i++)
                  {
                      cout<<*(Items+i)<< ", ";
                  }
                  if (Count!=0) cout<<*(Items+Count-1);
                  cout<<" }\n";
             }
      Mnojina Mnojina :: operator + (Mnojina b){

                Mnojina temp;
                for (int i = 0 ; i < Count ; i++)
                {
                    temp.Include(*(Items+i));
                }
                for (int i = 0 ; i < b.Count ; i++)
                {
                    temp.Include(*(b.Items+i));
                }               
               // temp.Show("Temp");

                return temp;
      }             
      Mnojina Mnojina :: operator - (Mnojina b){
                Mnojina temp;
                for (int i = 0 ; i < Count ; i++)
                {
                    temp.Include(*(Items+i));
                }
                for (int i = 0 ; i < b.Count ; i++)
                {
                    temp.Exclude(*(b.Items+i));
                }               
               // temp.Show("Temp");

                return temp;
      }
      Mnojina Mnojina :: operator * (Mnojina b){
                Mnojina temp;
                for (int i = 0 ; i < Count ; i++)
                {
                    for (int j = 0 ; j < b.Count ; j++)
                    {
if ( IsPresent(b.Items[j]) && b.IsPresent(Items[i])  ) {

         temp.Include(Items[i]);
 }
                    }
                }

               // temp.Show("Temp");

                return temp;
      }           

};
using namespace std;


int main(){
    Mnojina A,B,C;
    A.Include(1);
    A.Include(2);
    A.Include(3);       
    A.Include(4);
   
    B.Include(3);
    B.Include(4);
    B.Include(5);
    B.Include(6);

   
    A.Show("A");
    B.Show("B");
    C.Show("C");
    cout<<endl;
   
       
    C=A+B;
    C.Show("C=A+B");
    A.Show("A");
    B.Show("B");
    C.Show("C");
    cout<<endl;
   
    C=A-B;
    C.Show("C=A-B");
    cout<<endl;
    A.Show("A");
    B.Show("B");
    C.Show("C");
    cout<<endl;
     
     
    C=A*B;
    C.Show("C=A*B");
    cout<<endl;
    A.Show("A");
    B.Show("B");
    C.Show("C");     
   
    system("pause");
}

Василь написав:

Obi-Van написав:я не шарю як перевантажувати саме оператор присвоєння, інші в мене є...

Код: Виділити все

#include <stdio.h> // для printf
 
class X
{
    int x;
public:
    X() : x(0) {}
    explicit X(int i) : x(i) {}
    operator int() { return x; }
    X& operator=(const X& arg1) { x = arg1.x; return *this; }
    friend X operator+(const X&, const X&);
    friend X operator*(const X&, const X&);
};
 
// використання дружніх функцій дозволяє доступ до приватних членів класу
// і також дозволяє показати симетричність в оголошенні функції
inline X operator+(const X& arg1, const X& arg2)
{
    X r;
    r.x = arg1.x + arg2.x;
    return r;
}
 
inline X operator*(const X& arg1, const X& arg2)
{
    X r;
    r.x = arg1.x * arg2.x;
    return r;
}
 
int main()
{
    X x;
    x = X(5) + X(6) * X(7); // = 47 ( * має вищий пріоритет )
                            // x = 5 + 6 * 7; - не спрацює через використання explicit,
                            // а x = X(5 + 6 * 7); можна
    printf("%d\n", x); // завдяки operator int() х неявно перетворюється в int
}


Код: Виділити все

...
X operator+(const X&);
...
inline X X::operator+(const X& arg2)
{
    X r;
    r.x = x + arg2.x;
    return r;
}
...


aol написав:Знов таки відходите від парадигми ООП.
Все що стосується класу дуже бажано реалізовувати в межах класу.
Навіщо дружні функції, якщо обидва елементи є членами цього класу

Код: Виділити все

class Vector
{
      private:
          int e1, e2, e3, e4;
      public:
          Vector operator&(Vector);
          ...
          Vector operator~();
          Vector& operator=(const Vector&);
};
Vector Vector :: operator&(Vector v2)
{
       Vector v;
       v.e1 = e1 & v2.e1;
       v.e2 = e2 & v2.e2;
       v.e3 = e3 & v2.e3;
       v.e4 = e4 & v2.e4;       
       return v;     
}

...

Vector& Vector :: operator=(const Vector& v1)
{
       Vector v;
       e1 = v1.e1;
       e2 = v1.e2;
       e3 = v1.e3;
       e4 = v1.e4;
       return *this;
}

aol написав:inline - це тільки підказка оптимізатору, що цю функцію бажано при компіляції коду не викликати, а просто підставляти цілком тіло для прискорення роботи програми.

Питання з const & білш цікаве

Давайте почнемо з початку:
Якщо функція описана як f(int a), то передається до функції копія змінної а. Якщо змінна а не типу int а велика структура або об'єкт, то це ресурсоємна операція. Для випадку об'єкту складного класу створення його копії може займати багато часу та системних ресурсів. Як альтернатива використовувати передачу параметра за посиланням (by reference): f(int& a). Тоді у функцію передається не копія об'єкту (змінної) а, а тільки посилання на нього. Але як побочний ефект можливість змінити зміст змінної а у тілі функції. Для того, щоб унеможливити зміну змісту і використовують слово const. Фактично f( const int& a) майже рівнозначне до f(int a) але не потребує створення копії а при виклику функції.

Sergiych написав:Допоможи з лабою!
Завдання: реалізувати клас- група тварин. Реалізувати можливість включення та виключення тварин у групу, сортування їх за різними ознаками.
Бажано зробити до вівторка.
Наперед дякую!!!