How can I pass a int value to my member function operator += to insert int values into a object list in c++?

Question

I'm very new to c++ and have issues doing what seems like a simple task. I was given a main function to test and I have to create a class that correctly corresponds to the int main. Below is the class I've made so far. There's a lot more to it than what I've provided because I'm having issues starting off the basic parts of the class.

The task is to create a class that makes object lists of ints and can be manipulated with other functions that come later. For now, I am trying to set up the lists and inserting int n values.

#include<iostream>
#include<string>
#include<cmath>
#define DEFAULT 8
#define EMPTY -1
using namespace std;
// Your class specification goes here <<<<<<<<<<<<<<
class Myclass
{
  private:
   int *a = NULL;
   int end = EMPTY; 
   int size;
  public:
    Myclass(){} //default constructor
    Myclass(Myclass const &other);//copy constructor
    Myclass(Myclass &&other);//move constructor
    ~Myclass() {delete [] a;} //destructor 
    Myclass& operator=(const Myclass& other); //copy assignment
    Myclass& operator=(Myclass&& other); //move assignment
    Myclass& operator+=(const Myclass &other);
    Myclass& operator+(Myclassconst &other); // overload +
    friend ostream& operator<<(ostream &os, const Myclass& other);
};

this in my class so far and below is the definitions.

Myclass::Myclass(Myclass const &other) // copy constructor
{
  end = other.end;
  a = new int [DEFAULT];
  for (int i = 0; i <= end; i++)
   a[i] = other.a[i];
}
Myclass::Myclass(Myclass &&other) //move constructor
{
  a = new int [DEFAULT];
  for (int i = 0; i <= end; i++)
   a[i] = other.a[i];  
}
Myclass& Myclass::operator=(const Myclass& other) //overload =
{
  if (this == &other) // Check for self assignment
   return *this;
  end = other.end;
  delete [] a;
  a = new int [DEFAULT];
  for (int i = 0; i <= end; i++)
   a[i] = other.a[i];
  return *this;    
}
Myclass& Myclass::operator=(Myclass&& other)
{
  if(this != &other)
  {
    delete[] a;
    a = new int [DEFAULT];
    for (int i = 0; i <= end; i++)
    {
      a[i] = other.a[i];
    }
  }
  return *this;
}
Myclass& Myclass::operator+(Myclass const &other) //overload +
{
  Myclass answer;
  int index = 0;
  for (int i = 0; i < this->end; i++)
   answer.a[index++] = this->a[i];
  for (int i = 0; i <= other.end; i++)
   answer.a[index++] = other.a[i];
  return answer;  
}
Myclass& Myclass::operator+=(const Myclass&other)
 {
   Myclass answer;
  int index = 0;
  for (int i = 0; i < this->end; i++)
   answer.a[index++] = this->a[i];
   return answer;
 }

ostream& operator<<(ostream &os, const Myclass& other)
{
  for (int i = 0; i <= other.end; i++)
   os << other.a[i] << ", ";
  return os;  
}

My main issue is getting the += operator to work correctly as I keep getting the error about adding Myclass and an int together. My += function does not seem correct either but im not sure how to even correct it. I've commented out a2 and a3 because I'm not sure how to deal with the true or false of these objects either. Please help in any way or send me in a direction of information Id really appreciate it.

Sadly the point of the project was to use basics, I'm not allowed to use std::vector. how can I fix my management? — verticallypickled, Aug 26 '20 at 04:50
Start with perfecting the copy constructor. Once you have a good copy constructor, you can base the assignment operators off of it with a trick called the [Copy and Swap Idiom](https://stackoverflow.com/questions/3279543/what-is-the-copy-and-swap-idiom). The trick with the move special member functions is they steal the guts out of the source object and leave it in a safe-to-destroy state. You do not copy the source array, you *take* the source array. — user4581301, Aug 26 '20 at 05:38
Write a minimal `school::vector` the first time you should use `std::vector` but can't. The next time use `school::vector` (filling in missing things as needed) where people suggest `std::vector`. Then complain to your teacher that `std::vector` is not portably implementable prior to C++20. — Caleth, Aug 26 '20 at 10:31

Remy Lebeau · Answer 1 · 2020-08-26T06:54:42.623

Your operator+= doesn't accept an int as input, only another Alist, so a1 += n; will not work. You need to add another operator+= for that purpose.

Also, your array management is completely wrong in your constructors and assignment operators. Your copy constructor and copy assignment operator are not allocating enough memory to copy the entire other list if it has more than DEFAULT integers. And your move constructor and move assignment operator are not actually moving anything at all.

And there are other issues with all of your operators in general. Your concatenation operators are not appending to the array correctly. And the non-compound operators have the wrong return type. See What are the basic rules and idioms for operator overloading?

Try something more like this:

Alist.h

#ifndef ALIST_H
#define ALIST_H

#include <iostream>

class Alist
{
private:
    int *a = nullptr;
    int size = 0;
    int capacity = 0;

public:
    Alist() = default; //default constructor
    Alist(int initialCap);
    Alist(Alist const &other); //copy constructor
    Alist(Alist &&other); //move constructor

    ~Alist(); //destructor

    void swap(Alist &other);

    Alist& operator=(Alist other); //copy+move assignment
    Alist& operator+=(const Alist &other);
    Alist& operator+=(int value);
    Alist operator+(const Alist &other) const; // overload +
    Alist operator+(int value) const;
    //int& operator[](int index);

    friend std::ostream& operator<<(std::ostream &os, const Alist& list);
};

void swap(Alist &a1, Alist &a2);

#endif

Alist.cpp

#include "Alist.h"
#include <utility>

#define GROWTH 8 // must be a power of 2!

Alist::Alist(int initialCap)
    : Alist()
{
    if (initialCap > 0) {
        capacity = (initialCap + (GROWTH-1)) & ~(GROWTH-1);
        a = new int [capacity];
    }
}

Alist::Alist(const Alist &other)
    : Alist(other.size)
{
    size = other.size;
    for (int i = 0; i < size; ++i) {
        a[i] = other.a[i];
    }
}

Alist::Alist(Alist &&other)
    : Alist()
{
    other.swap(*this);
}

Alist::~Alist()
{
    delete [] a;
}

void Alist::swap(Alist &other)
{
    std::swap(capacity, other.capacity);
    std::swap(size, other.size);
    std::swap(a, other.a);
}

Alist& Alist::operator=(Alist other)
{
    other.swap(*this);
    return *this;
}

Alist Alist::operator+(const Alist &other) const
{
    Alist answer(size + other.size);
    answer += *this;
    answer += other;
    return answer;
}

Alist Alist::operator+(int value) const
{
    Alist answer(size + 1);
    answer += *this;
    answer += value;
    return answer;
}

Alist& Alist::operator+=(const Alist &other)
{
    if ((size + other.size) > capacity)
    {
        Alist tmp(size + other.size);
        tmp += *this;
        tmp.swap(*this);
    }
    for (int i = 0; i < other.size; ++i) {
        a[size++] = other.a[i];
    }
    return *this;
}

Alist& Alist::operator+=(int value)
{
    if ((size + 1) > capacity)
    {
        Alist tmp(size + 1);
        tmp += *this;
        tmp.swap(*this);
    }
    a[size++] = value;
    return *this;
}

//int& Alist::operator[](int index)
//{
// return a[index];
//}

std::ostream& operator<<(std::ostream &os, const Alist& list)
{
    for (int i = 0; i < list.size; i++)
        os << list.a[i] << ", ";
    return os;
}

void swap(Alist &a1, Alist &a2)
{
    a1.swap(a2);
}

Any upside/downside to using `std::copy` instead of a loop to fill `a` from `other.a`? — David C. Rankin, Aug 26 '20 at 07:08
@DavidC.Rankin no. It would be preferred, actually. But since the OP is not allowed to use `std::vector`, I'm guessing `std::copy()` is not allowed, too. — Remy Lebeau, Aug 26 '20 at 07:18
Wow, thank you for this in-depth work! I really appreciate your time! @RemyLebeau — verticallypickled, Aug 26 '20 at 11:53

How can I pass a int value to my member function operator += to insert int values into a object list in c++?

1 Answers1