如何将int值传递给成员函数运算符+ =以将int值插入c ++中的对象列表中？

如何解决如何将int值传递给成员函数运算符+ =以将int值插入c ++中的对象列表中？

我对C ++还是很陌生，在执行看似简单的任务时遇到了问题。给了我一个main函数进行测试，并且我必须创建一个与int main正确对应的类。以下是我到目前为止所做的课程。除了我提供的内容以外，还有很多其他功能，因为我在上课的基本部分时遇到了问题。

任务是创建一个类，该类列出int的对象列表，并且可以用以后提供的其他函数来操作。现在，我正在尝试设置列表并插入int n值。

#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);
};

到目前为止，我班上的这是定义。

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;  
}

我的主要问题是让+ =运算符正常工作，因为我不断收到有关将Myclass和int一起添加的错误。我的+ =函数似乎也不正确，但是我不确定如何更正它。我已经注释掉了a2和a3，因为我不确定如何处理这些对象的是非。 请以任何方式提供帮助或向我发送有关我非常感激的信息。

解决方法

您的operator+=不接受int作为输入，仅接受另一个Alist，因此a1 += n;将不起作用。为此，您需要添加另一个operator+=。

此外，在构造函数和赋值运算符中，数组管理是完全错误的。您的副本构造函数和副本分配运算符未分配足够的内存来复制整个other列表（如果整数多于DEFAULT）。而且您的move构造函数和move赋值运算符实际上根本不移动任何东西。

一般来说，所有运营商都存在其他问题。您的串联运算符未正确附加到数组。非复合运算符的返回类型错误。参见What are the basic rules and idioms for operator overloading?

尝试更多类似的方法：

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);
}