idk

Makefile

@@ -1,4 +1,4 @@
-	export BUILD_CMD=clang++ -Wall -std=c++17 -Wall -Wextra
+	export BUILD_CMD=clang++ -Wall -std=c++17 -Wall -Wextra -O1 -g -fsanitize=address -fno-omit-frame-pointer
 
 setup:
 	mkdir build

src/sheet04.cpp

@@ -2,10 +2,12 @@
 #include <array>
 #include <initializer_list>
 #include <cmath>
+#include <iostream>
+#include <vector>
+
 class vec
 {
     private:
-    const double nan = std::nan("");
     unsigned vec_size;
     double *vector;
     public:
@@ -24,11 +26,11 @@ class vec
     }
 
     ~vec() {delete[] vector;}
-    vec(const vec &m) : vec_size(m.vec_size), vector(new double[vec_size])
+    vec(const vec &m) : vec_size(m.size()), vector(new double[m.size()])
     {
-        for(size_t i=0; i<vec_size;++i)
+        for(size_t i=0; i<m.size();++i)
         {
-            vector[i] = m.vector[i];
+            (*this)[i] = m[i];
         }
     }
 
@@ -38,7 +40,7 @@ class vec
         {
             vec_size = m.vec_size;
             delete[] vector;
-            vector = new double[vec_size];
+            vector = new double[m.vec_size];
 
             for(size_t i = 0; i<vec_size; ++i)
             {
@@ -48,15 +50,18 @@ class vec
         return *this;
     }
 
-    vec(vec &&m) : vec_size(m.vec_size), vector(new double[vec_size])
+    vec(vec &&m) : vec_size(m.size()), vector(m.vector)
     {
-        vector = std::move(m.vector);
+        m.vector = nullptr;
     }
 
     vec& operator= (vec &&m)
     {
-        vec_size = m.vec_size;
-        vector = std::move(m.vector);
+        if(this != &m)
+        {
+            vec_size = m.size();
+            vector = m.vector;
+        }
         return *this;
     }
 
@@ -64,14 +69,200 @@ class vec
     {
         return vec_size;
     }
+    size_t size() const
+    {
+        return vec_size;
+    }
 
     double& operator[] (size_t idx)
     {
-        if(idx>vec_size)
-        {
-            return nan;
-        }
+        try{
+            if(idx>vec_size)
+            {
+                throw (idx);
+            }
 
+            return vector[idx];
+        }
+        catch (size_t i)
+        {
+            std::cout << "Invalid vector index: " << idx << '\n';
+            idx = size() - 1;
+        }
         return vector[idx];
     }
-};
+
+    const double& operator[] (size_t idx) const
+    {
+        try{
+            if(idx>vec_size)
+            {
+                throw (idx);
+            }
+
+            return vector[idx];
+        }
+        catch (size_t i)
+        {
+            std::cout << "Invalid vector index: " << idx << '\n';
+            idx = size() - 1;
+        }
+        return vector[idx];
+    }
+
+    friend std::ostream& operator<< (std::ostream &os, const vec &v)
+    {
+        os << '[';
+        for(size_t i=0; i<v.vec_size; ++i)
+        {
+            os << v.vector[i];
+            if(i<v.vec_size-1)
+            {
+                os << ", ";
+            }
+            else
+            {
+                os << ']';
+                return os;
+            }
+        }
+        return os;
+    }
+
+    friend vec operator+ (vec lhs, const vec &rhs)
+    {
+        vec out(lhs.size(), NAN);
+        try
+        {
+            if(lhs.size()!=rhs.size())
+            {
+                throw(rhs.size());              
+            }
+
+            for(size_t i=0; i<lhs.size(); ++i)
+            {
+                out[i] = lhs[i]+rhs[i];
+            }
+        }
+        catch (size_t i)
+        {
+            std::cout << "Invalid right hand side vector size: " << i << '\n';
+        }
+        return out;
+    }
+
+    friend vec operator- (vec lhs, const vec &rhs)
+    {
+        vec out(lhs.size(), NAN);
+        try
+        {
+            if(lhs.size()!=rhs.size())
+            {
+                throw(rhs.size());              
+            }
+
+            for(size_t i=0; i<lhs.size(); ++i)
+            {
+                out[i] = rhs[i]-rhs[i];
+            }
+        }
+        catch (size_t i)
+        {
+            std::cout << "Invalid right hand side vector size: " << i << '\n';
+        }
+        return out;
+    }
+
+    friend vec operator* (vec lhs, double scale)
+    {
+        vec out(lhs.size());
+        for(size_t i = 0; i<out.size();++i)
+        {
+            out[i] = lhs[i] * scale;
+        }
+        return out;
+    }
+
+    friend double operator* (const vec &lhs, const vec &rhs)
+    {
+        double sum = 0;
+        try
+        {
+            if(lhs.size()!=rhs.size())
+            {
+                throw(rhs.size());
+            }
+
+            for(size_t i=0;i<lhs.size();++i)
+            {
+                sum += lhs[i] + rhs[i];
+            }
+        }
+        catch (size_t i)
+        {
+            std::cout << "Invalid right hand side vector size: " << i << '\n';
+            sum = NAN;
+        }
+        return sum;
+    }
+ };
+ void bubble_sort(std::vector<int> &v, size_t from, size_t to);
+
+ int main()
+ {
+    std::string  ans;
+    std::cout << "y for vector exercies: ";
+    std::cin >> ans;
+    if(ans == "y")
+    {
+        vec vec2(2);
+        vec2[0] = 1;
+        vec2[1] = 1;
+        std::cout << vec2 << '\n';
+        vec vec3(3, 1);
+        std::cout << vec3 << '\n';
+        vec vec3p3(vec3+vec3);
+        std::cout << vec3p3 << '\n';
+        vec vec3m3(vec3-vec3);
+        std::cout << vec3m3 << '\n';
+        double vec3x3(vec3*vec3);
+        std::cout << vec3x3 << '\n';
+        vec vec3x2(vec3*3);
+        std::cout << vec3x2 << '\n';
+        vec vec4 = {1,1,1,1};
+        vec4[1] = vec3x2[1];
+        std::cout << vec4 << '\n';
+        std::cout << vec3*vec4 << '\n';
+        vec vec5 = vec4;
+        std::cout << vec5 << '\n';
+        vec vec6 = std::move(vec5);
+        std::cout << vec6 << '\n';
+        vec vec7(std::move(vec6));
+        std::cout << vec7 << '\n';
+    }
+    std::vector<int> v = {1,5,6,23,7,8,9,21,12,4};
+    for(size_t i=0; i<v.size(); ++i) {std::cout << v[i] << " ";}
+    std::cout << "\n";
+    bubble_sort(v,0,8);
+    for(size_t i=0; i<v.size(); ++i) {std::cout << v[i] << " "; }
+    std::cout << "\n";
+ }
+
+ void bubble_sort(std::vector<int> &v, size_t from, size_t to)
+ {
+    if(from > v.size()-1 || to < from) { return; }
+    if(to > v.size()-1) {to = v.size()-1; }
+    bool unsorted;
+    do
+    {
+        unsorted = false;
+        for(size_t i = from; i<=to-1;++i)
+        {
+            if(v[i]>v[i+1])
+            {
+                std::swap(v[i],v[i+1]);
+                unsorted = true;
+            }
+        }
+    }while(unsorted);
+ }