Facebook
From Cobalt Agouti, 4 Years ago, written in C++.
Embed
Download Paste or View Raw
Hits: 276
  1. #include <stdio.h>
  2. #include <conio.h>
  3. #include <malloc.h>
  4. #include <cmath>
  5.  
  6. class Vector
  7. {
  8. public:
  9.         static const int increment = 1;
  10.  
  11.         Vector();
  12.         Vector(const int, const double);
  13.         Vector(const Vector&);
  14.  
  15.         Vector& operator = (const Vector&);
  16.         Vector operator + (const Vector&) const;
  17.         Vector operator - (const Vector&) const;
  18.         Vector operator * (const Vector&) const;
  19.  
  20.         double& operator [] (unsigned int i);
  21.         const double operator [] (unsigned int i) const;
  22.         double& operator () (unsigned int i);
  23.         const double operator () (unsigned int i) const;
  24.  
  25.         operator int() const;
  26.  
  27.         size_t Size() const;
  28.         void Display() const;
  29.         Vector& PushBack(const double);
  30.  
  31. private:
  32.         double *tab;
  33.         unsigned int size;
  34. };
  35.  
  36. Vector::Vector()
  37. {
  38.         size = 0;
  39.         tab = NULL;
  40. }
  41.  
  42. Vector::Vector(const int N, const double M)
  43. {
  44.         size = 0;
  45.         tab = (double*)malloc(N*sizeof(double));
  46.         if (tab != NULL)
  47.         {
  48.                 size = N;
  49.                 for (unsigned int i = 0; i < size; i++)
  50.                 {
  51.                         tab[i] = M;
  52.                 }
  53.         }
  54. }
  55.  
  56. Vector::Vector(const Vector& vect)
  57. {
  58.         size = 0;
  59.         tab = (double*)malloc(vect.size*sizeof(double));
  60.         if (tab != NULL)
  61.         {
  62.                 size = vect.size;
  63.                 for (unsigned int i = 0; i < size; i++)
  64.                 {
  65.                         tab[i] = vect.tab[i];
  66.                 }
  67.         }
  68. }
  69.  
  70. Vector& Vector::operator = (const Vector& vect)
  71. {
  72.         size = 0;
  73.         tab = (double*)malloc(vect.size*sizeof(double));
  74.         if (tab != NULL)
  75.         {
  76.                 size = vect.size;
  77.                 for (unsigned int i = 0; i < size; i++)
  78.                 {
  79.                         tab[i] = vect.tab[i];
  80.                 }
  81.         }
  82.         return *this;
  83. }
  84.  
  85. Vector Vector::operator + (const Vector& vect) const
  86. {
  87.         Vector Vect;
  88.         if (size >= vect.size)
  89.         {
  90.                 for (unsigned int i = 0; i < size; i++)
  91.                 {
  92.                         if (i <= vect.size)
  93.                         {
  94.                                 Vect.PushBack(tab[i] + vect.tab[i]);
  95.                         }
  96.                         else
  97.                         {
  98.                                 Vect.PushBack(tab[i]);
  99.                         }
  100.                 }
  101.         }
  102.         else
  103.         {
  104.                 for (unsigned int i = 0; i < vect.size; i++)
  105.                 {
  106.                         if (i <= size)
  107.                         {
  108.                                 Vect.PushBack(tab[i] + vect.tab[i]);
  109.                         }
  110.                         else
  111.                         {
  112.                                 Vect.PushBack(vect.tab[i]);
  113.                         }
  114.                 }
  115.         }
  116.         return Vect;
  117. }
  118.  
  119. Vector Vector::operator - (const Vector& vect) const
  120. {
  121.         Vector Vect;
  122.         if (size >= vect.size)
  123.         {
  124.                 for (unsigned int i = 0; i < size; i++)
  125.                 {
  126.                         if (i <= vect.size)
  127.                         {
  128.                                 Vect.PushBack(tab[i] - vect.tab[i]);
  129.                         }
  130.                         else
  131.                         {
  132.                                 Vect.PushBack(tab[i]);
  133.                         }
  134.                 }
  135.         }
  136.         else
  137.         {
  138.                 for (unsigned int i = 0; i < vect.size; i++)
  139.                 {
  140.                         if (i <= size)
  141.                         {
  142.                                 Vect.PushBack(tab[i] - vect.tab[i]);
  143.                         }
  144.                         else
  145.                         {
  146.                                 Vect.PushBack(vect.tab[i]);
  147.                         }
  148.                 }
  149.         }
  150.         return Vect;
  151. }
  152.  
  153. Vector Vector::operator * (const Vector& vect) const
  154. {
  155.         Vector Vect;
  156.         if (size >= vect.size)
  157.         {
  158.                 for (unsigned int i = 0; i < size; i++)
  159.                 {
  160.                         if (i <= vect.size)
  161.                         {
  162.                                 Vect.PushBack(tab[i] * vect.tab[i]);
  163.                         }
  164.                         else
  165.                         {
  166.                                 Vect.PushBack(tab[i]);
  167.                         }
  168.                 }
  169.         }
  170.         else
  171.         {
  172.                 for (unsigned int i = 0; i < vect.size; i++)
  173.                 {
  174.                         if (i <= size)
  175.                         {
  176.                                 Vect.PushBack(tab[i] * vect.tab[i]);
  177.                         }
  178.                         else
  179.                         {
  180.                                 Vect.PushBack(vect.tab[i]);
  181.                         }
  182.                 }
  183.         }
  184.         return Vect;
  185. }
  186.  
  187. double& Vector::operator [] (unsigned int i)
  188. {
  189.         return tab[i];
  190. }
  191.  
  192. const double Vector::operator [] (unsigned int i) const
  193. {
  194.         return tab[i];
  195. }
  196.  
  197. double& Vector::operator () (unsigned int i)
  198. {
  199.         return tab[i];
  200. }
  201.  
  202. const double Vector::operator () (unsigned int i) const
  203. {
  204.         return tab[i];
  205. }
  206.  
  207. size_t Vector::Size() const
  208. {
  209.         return size;
  210. }
  211.  
  212. Vector::operator int() const
  213. {
  214.         return ceil(tab[0]);
  215. }
  216.  
  217. Vector& Vector::PushBack(const double value)
  218. {
  219.         tab = (double*)realloc(tab, (size + increment) * sizeof(double));
  220.         if (tab)
  221.         {
  222.                 tab[size] = value;
  223.                 ++size;
  224.         }
  225.         return *this;
  226. }
  227.  
  228. void Vector::Display() const
  229. {
  230.         printf("[");
  231.         for (unsigned int i = 0; i < size; i++)
  232.         {
  233.                 if (i == size - 1)
  234.                 {
  235.                         printf("%.2lf", tab[i]);
  236.                 }
  237.                 else
  238.                 {
  239.                         printf("%.2lf, ", tab[i]);
  240.                 }
  241.         }
  242.         printf("]\n");
  243. }
  244.  
  245. int main()
  246. {
  247.         Vector Wektor1, Wektor2(5, 15.0);
  248.         Vector Wektor3 = Wektor2;
  249.  
  250.         printf("Wektor 1: \n");
  251.         Wektor1.Display();
  252.         printf("Rozmiar - %i\n\n", Wektor1.Size());
  253.  
  254.         printf("Wektor 2: \n");
  255.         Wektor2.Display();
  256.         printf("Rozmiar - %i\n\n", Wektor2.Size());
  257.  
  258.         printf("Wektor 3: \n");
  259.         Wektor3.Display();
  260.         printf("Rozmiar - %i\n\n", Wektor3.Size());
  261.  
  262.         for (unsigned int i = 0; i < 3; i++)
  263.         {
  264.                 Wektor1.PushBack((i + 1) * 6.32);
  265.                 Wektor3.PushBack((i + 1) * 1.26);
  266.         }
  267.  
  268.         printf("Wektor 1: \n");
  269.         Wektor1.Display();
  270.         printf("Rozmiar - %i\n\n", Wektor1.Size());
  271.  
  272.         printf("Wektor 2: \n");
  273.         Wektor2.Display();
  274.         printf("Rozmiar - %i\n\n", Wektor2.Size());
  275.  
  276.         printf("Wektor 3: \n");
  277.         Wektor3.Display();
  278.         printf("Rozmiar - %i\n\n", Wektor3.Size());
  279.  
  280.         Wektor2 = Wektor1 + Wektor2;
  281.  
  282.         printf("Wektor 2: \n");
  283.         Wektor2.Display();
  284.         printf("Rozmiar - %i\n\n", Wektor2.Size());
  285.  
  286.         Wektor3 = (Wektor1 - Wektor3) * Wektor2;
  287.  
  288.         printf("Wektor 3: \n");
  289.         Wektor3.Display();
  290.         printf("Rozmiar - %i\n\n", Wektor3.Size());
  291.  
  292.         printf("Wektor 3 -> tab[0] = %.2lf\n", Wektor3[0]);
  293.  
  294.         Wektor3[0] = 14.04;
  295.         Wektor3(1) = 3.33;
  296.  
  297.         printf("Wektor 3 -> tab[0] = %.2lf\n", Wektor3[0]);
  298.         printf("Wektor 3 -> tab[1] = %.2lf\n", Wektor3(1));
  299.  
  300.         int zeroIndex = (int)Wektor3;
  301.         printf("Wektor3, Tab[0] INT = %i", zeroIndex);
  302.  
  303.         _getch();
  304.         return 0;
  305. }
  306.