Перегрузка операторов, нечетная ошибка сегмента, классы, C++

Question

Мне было поручено выполнять перегрузку операторов моим наставником. Он дал мне функцию int main(), которая не может быть изменена. Я должен был написать функции и т. Д., Чтобы код работал. К сожалению, у меня есть ошибка. Я заметил, что если

TSeries series4=series1(2,4); 
cout << "Series4: " << series4 << endl; 

строки прокомментированы, что это более или менее работает. Я был бы очень благодарен за вашу помощь.

#include <iostream> 
class TSeries { 
public: 
    TSeries() 
    { 
     _size = 0; 
     _capacity = 0; 
     _tab = NULL; 
    } 


    TSeries(float *tab, const int size) 
    { 
     _tab = new float[size]; 
     for (int i = 0; i < size; i++) _tab[i] = tab[i]; 
     _size = size; 
     _capacity = 0; 
    } 

    ~TSeries() { delete[] _tab; } 

    TSeries & operator+=(float value) { return insert(value); } 
    TSeries & operator,(float value) { return insert(value); } 
    TSeries & operator+(const TSeries & s) 
    { 
     // if(this->_size != s._size) std::cout<<"Size doesn't match!"<<std::endl; 
     /*else 
     { 
     std::cout<<"whee"; 
     for(int i; i<this->_size;i++) 
     { 
     //this->_tab[i] += s._tab[i]; 
     std::cout<<"nothing"; 
     } 
     return *this; 
     }*/ 
     //std::cout<<"sth"; 
    } 

    TSeries & operator()(int position1, int position2) 
    { 
     // return *this; 
    } 

    TSeries & insert(float k) 
    { 
     if (_size >= _capacity) Enlarge(); 
     _tab[_size++] = k; 
     return *this; 
    } 
    friend std::ostream & operator<<(std::ostream & out, const TSeries & s); 


private: 
    int _size, _capacity; 
    float *_tab, *_itr; 
    static int _nr; 

    void Enlarge() 
    { 
     _capacity = 2 * _capacity + 1; 
     float *tmp = new float[_capacity]; 

     for (int i = 0; i < _size; ++i) 
     { 
      tmp[i] = _tab[i]; 
     } 
     delete[] _tab; 
     _tab = tmp; 
    } 
}; 

std::ostream & operator<<(std::ostream & out, const TSeries & s) 
{ 
    int przedostatni = s._size - 1; 
    out << "("; 
    for (int i = 0; i < s._size; i++) 
    { 
     out << (int)s._tab[i]; 
     if (i != przedostatni) 
      out << ","; 
    } 
    out << ")" << std::endl; 
} 

using namespace std; 
int main(int argc, char **argv) { 
    TSeries series1; 
    series1 += 1., 2., 4., 2.; 
    cout << "Series1: " << series1 << endl; 

    const int size = 7; 
    float tab[size] = { 3.,3.,3.,4.,5.,1.,0. }; 
    const TSeries series2(tab, size); 
    cout << "Series2: " << series2 << endl << endl; 


    TSeries series3 = series1 + series2; 
    cout << "Series3: " << series3 << endl << endl; 

    series1 += 1., 0., 3.; 
    series3 = series1 + series2; 
    cout << "   " << series1 << endl; 
    cout << "   +" << series2 << endl; 
    cout << "  ---------------------" << endl; 
    cout << "Series3: " << series3 << endl << endl; 

    TSeries series4 = series1(2, 4); 
    cout << "Series4: " << series4 << endl; 

    return 0; 
} 

/* output required: 
Series1: (1,2,4,2) 
Series2: (3,3,3,4,5,1,0) 

Size doesn't match! 
Series3:() 

(1,2,4,2,1,0,3) 
+(3,3,3,4,5,1,0) 
--------------------- 
Series3: (4,5,7,6,6,1,3) 

Series4: (4,2) 
*/ 

Answer 1

1. std::ostream & operator<<(std::ostream & out, const TSeries & s) не возвращает ничего. Пожалуйста, добавьте return out в конце функции
2. operator() и operator+ оба должны заканчиваться return *this
3. Как Devolus уже указал: Вы не конструктор копирования и не operator=(const TSeries&) не определено
4. Вы можете использовать memcpy, чтобы скопировать массивы быстрее. #
5. i в for-loop в operator+(const TSeries&) не инициализируется.
6. Ваш operator(int, int) в настоящее время изменяет исходный объект. Это не кажется правильным.

Код:

#include <iostream> 
class TSeries { 
public: 
    TSeries() 
    { 
     _size = 0; 
     _capacity = 0; 

     _tab = NULL; 
    } 


    TSeries(float *tab, const int size) 
    { 
     _size = size; 
     _capacity = 0; 

     _tab = new float[size]; 
     memcpy(_tab, tab, _size*sizeof(float)); 
    } 

    TSeries(const TSeries& other) 
    { 
     _size = other._size; 
     _capacity = other._capacity; 

     _tab = new float[_size]; 
     memcpy(_tab, other._tab, _size*sizeof(float)); 
    } 

    ~TSeries() 
    { 
     delete[] _tab; 
    } 

    TSeries & operator+=(float value) { return insert(value); } 
    TSeries & operator,(float value) { return insert(value); } 
    TSeries & operator+(const TSeries & other) 
    { 
     if (this->_size != other._size) 
     { 
      std::cout << "Size doesn't match!" << std::endl; 
     } 
     else 
     { 
      //std::cout << "whee"; 
      for (int i = 0; i < this->_size; i++) 
      { 
       _tab[i] += other._tab[i]; 
       //std::cout << "nothing"; 
      } 
     } 
     //std::cout<<"sth"; 
     return *this; 
    } 

    TSeries& operator=(const TSeries& other) 
    { 
     _size = other._size; 
     _capacity = other._capacity; 
     //Create tmp in case of self-assignment 
     float *tmp = new float[_capacity]; 
     memcpy(tmp, other._tab, _size*sizeof(float)); 
     delete[] _tab; 
     _tab = tmp; 
     return *this; 
    } 

    TSeries operator()(int position1, int position2) 
    { 
     //TODO: Range-Check 
     return TSeries(_tab + position1, position2 - position1); 
    } 

    TSeries & insert(float k) 
    { 
     if (_size >= _capacity) Enlarge(); 
     _tab[_size++] = k; 
     return *this; 
    } 
    friend std::ostream & operator<<(std::ostream & out, const TSeries & s); 


private: 
    int _size, _capacity; 
    float *_tab, *_itr; 
    static int _nr; 

    void Enlarge() 
    { 
     _capacity = 2 * _capacity + 1; 
     float *tmp = new float[_capacity]; 
     memcpy(tmp, _tab, _size*sizeof(float)); 
     delete[] _tab; 
     _tab = tmp; 
    } 
}; 

std::ostream & operator<<(std::ostream & out, const TSeries & s) 
{ 
    int przedostatni = s._size - 1; 
    out << "("; 
    for (int i = 0; i < s._size; i++) 
    { 
     out << (int)s._tab[i]; 
     if (i != przedostatni) 
      out << ","; 
    } 
    out << ")" << std::endl; 
    return out; 
} 

using namespace std; 
int main(int argc, char **argv) { 
    TSeries series1; 
    series1 += 1., 2., 4., 2.; 
    cout << "Series1: " << series1 << endl; 

    const int size = 7; 
    float tab[size] = { 3.,3.,3.,4.,5.,1.,0. }; 
    const TSeries series2(tab, size); 
    cout << "Series2: " << series2 << endl << endl; 


    TSeries series3 = series1 + series2; 
    cout << "Series3: " << series3 << endl << endl; 

    series1 += 1., 0., 3.; 
    series3 = series1 + series2; 
    cout << "   " << series1 << endl; 
    cout << "   +" << series2 << endl; 
    cout << "  ---------------------" << endl; 
    cout << "Series3: " << series3 << endl << endl; 

    TSeries series4 = series1(2, 4); 
    cout << "Series4: " << series4 << endl; 

    return 0; 
} 

/* output required: 
Series1: (1,2,4,2) 
Series2: (3,3,3,4,5,1,0) 

Size doesn't match! 
Series3:() 

(1,2,4,2,1,0,3) 
+(3,3,3,4,5,1,0) 
--------------------- 
Series3: (4,5,7,6,6,1,3) 

Series4: (4,2) 
*/ 

Выход

Series1: (1,2,4,2) 

Series2: (3,3,3,4,5,1,0) 


Size doesn't match! 
Series3: (1,2,4,2) 


      (4,5,7,6,6,1,3) 

      +(3,3,3,4,5,1,0) 

     --------------------- 
Series3: (4,5,7,6,6,1,3) 


Series4: (7,6) 

UPDATE:

Ваш operator+(const TSeries &) должен выглядеть примерно так:

TSeries operator+(const TSeries & other) 
{ 
    if (this->_size != other._size) 
    { 
     std::cout << "Size doesn't match!" << std::endl; 
     return TSeries(); //Return empty object 
    } 
    TSeries tmp(*this); //Create copy 
    for (int i = 0; i < tmp._size; i++) 
    { 
     tmp._tab[i] += other._tab[i]; 
    } 
    return tmp; 
} 

И ваш operator()(int, int) так:

TSeries operator()(int position1, int position2) 
{ 
    if (position1 < 0) position1 = 0; 
    else if (position1 >= _size) position1 = _size - 1; 

    if (position2 < position1) position2 = position1; 
    else if (position2 >= _size) position2 = _size - 1; 

    return TSeries(_tab + position1, position2 - position1); 
} 

Может быть, вы хотите, чтобы бросить исключения в случаях ошибки?