声明字段为const调用“函数operator =（const memAddress＆）无法引用 - 它是一个已删除的函数”

Posted 2021-04-01

我有一个存储和操作内存地址的结构。我决定将其中一个字段从int更改为const int以确保它是只读的，突然我定义的operator-（）抱怨以下消息：

函数“memAddress :: operator =（const memAddress＆）”（隐式声明）不能被引用 - 它是一个已删除的函数

这是代码，

struct memAddress
{
    // memory location variables
    int die = 0;
    int plane = 0;
    int page = 0;
    int column = 0;
    int block = _BLOCK_STARTING_ADDRESS;

    memAddress() {}

    memAddress(const memAddress &m)
    {
        die = m.die;
        plane = m.plane;
        page = m.page;
        column = m.column;
        block = m.block;
    }

    bool operator<(const memAddress &m)
    {
        if (die > m.die)
            return false;
        else if (die == m.die)
        {
            if (plane > m.plane)
                return false;
            else if (plane == m.plane)
            {
                if (block > m.block)
                    return false;
                else if (block == m.block)
                {
                    if (page > m.page)
                        return false;
                    else if (page == m.page)
                    {
                        if (column >= m.column)
                            return false;
                        else
                            return true;
                    }
                    else
                        return true;
                }
                else
                    return true;
            }
            else
                return true;
        }
        else
            return true;

    }

    bool operator==(const memAddress &m)
    {
        if (die == m.die &&
            plane == m.plane &&
            block == m.block &&
            page == m.page &&
            column == m.column)
        {
            return true;
        }

        return false;
    }

    bool operator<=(const memAddress &m)
    {
        if ((*this < m) || (*this == m))
            return true;

        return false;
    }

    bool operator>(const memAddress &m)
    {
        if (!(*this <= m))
            return true;

        return false;
    }

    bool operator>=(const memAddress &m)
    {
        if ((*this > m) || (*this == m))
            return true;

        return false;
    }

    memAddress operator-(const memAddress &m)
    {
        memAddress diff, a1, a2;

        if (*this < m)
        {
            a2 = m; // **error** 
            a1 = *this; // **error**
        }
        else
        {
            a2 = *this; // **error**
            a1 = m; // **error**
        }

        diff.die = a2.die - a1.die;
        diff.plane = a2.plane - a1.plane;
        diff.block = a2.block - a1.block;
        diff.page = a2.page - a1.page;
        diff.column = a2.column - a1.column;

        return diff;

    }

private:
    const int _BLOCK_STARTING_ADDRESS = 2; // **modifier added here**

};

我不知道为什么会这样 - 如果修改器被删除，代码工作正常。

为什么将字段修饰符更改为const会导致此行为？我该怎么办呢？

答案

由于您具有const非类类型（const int _BLOCK_STARTING_ADDRESS）的非静态数据成员，因此将删除默认赋值运算符。

使成员static将生成默认赋值运算符。

CPP草案（N4713）说明了关于赋值运算符：

15.8.2复制/移动赋值运算符 ... 7.如果X具有以下内容，则将类X的默认复制/移动赋值运算符定义为已删除： （7.1） - 具有非平凡对应赋值运算符的变体成员，X是类似联合的类，或 （7.2） - const非类型（或其数组）的非静态数据成员，或 （7.3） - 引用类型的非静态数据成员，或 （7.4） - 类型M（或其数组）的直接非静态数据成员或无法复制/移动的直接基类M，因为重载解析（16.3），如应用于查找M的相应赋值运算符，导致从默认赋值运算符中删除或无法访问的歧义或函数。

另一答案

您使用所有大写字母（以及使用它来初始化block）表示您打算将_BLOCK_STARTING_ADDRESS作为所有实例的类常量。

首先，让它静止不动

static const int _BLOCK_STARTING_ADDRESS = 2;

为什么？因为否则它是每个实例的数据成员。意味着每个实例都有一小部分必须是const，并且默认情况下不能分配给该const位。由于这个原因，编译器无法为您生成默认赋值运算符。

另外，作为一方而不是。以_[A-Z]开头的名称保留给C ++实现以供任何使用。为了避免鼻子恶魔的可能性，我建议你改变它的命名方案。也许甚至与less shouting一个？