Question

目标

我正在努力实现IntegerRing，这是抽象代数中的结构。这种类型的戒指是阿贝尔集团（我已经实施过的东西）。戒指配备两个操作员，+和*。

实施选择

出于这个原因，我决定将IntegerGroup定义为具有GroupElement个具有运算符的类。完整的工作代码如下：

IntegerGroup.h

#ifndef DATAGROUP_H
#define DATAGROUP_H

#include "Array.h"

#include <iostream>

// This group is the integers mod n
// multiplication in integer group is simply integer addition modulo n
class IntegerGroup
{
    public:
        IntegerGroup();
        IntegerGroup(int);
        class GroupElement
        {
            int m;
            IntegerGroup* group;
            public: 
                GroupElement();
                GroupElement(int, IntegerGroup*);
                ~GroupElement();
                GroupElement operator*(const GroupElement&);
                GroupElement operator*=(const GroupElement&);
                bool operator==(const GroupElement&);
                bool operator!=(const GroupElement&);
                int val() const;
                friend std::ostream& operator<<(std::ostream& o, const GroupElement& e)
                {
                    return (o << e.m);
                }

        };
        GroupElement identity() const;
        int size() const;
        friend std::ostream& operator<<(std::ostream& o, const IntegerGroup& g)
        {
            return (o << g.elements);
        }
    private:
        int n;
        //GroupElement * identity;
        Array<GroupElement> elements;
        void createNewElement(int);
};

#endif

IntegerGroup.cpp

#include "IntegerGroup.h"

#include <new>
#include <iostream>

IntegerGroup::IntegerGroup()
{

}

IntegerGroup::IntegerGroup(int n)
 : n(n), elements(Array<IntegerGroup::GroupElement>(n))
{
    //this is to have integers in [0,n-1]
    for (int j = 0; j < n; j++)
    {
        this->createNewElement(j);
    }
}

void IntegerGroup::createNewElement(int m)
{
    // create new GroupElement
    GroupElement newElement(m, this);
    // store it at index m in elements
    this->elements[m] = newElement;
}

IntegerGroup::GroupElement::GroupElement() 
    : group(0)
{

}


IntegerGroup::GroupElement::GroupElement(int m, IntegerGroup * g)
    : group(g)
{
    // this->m must be in [0, g->size() - 1]
    this->m = m % g->size();
    if (this->m < 0) this->m = g->size() + this->m;
}

IntegerGroup::GroupElement::~GroupElement()
{
    if (this->group)
    {
        this->group = 0;
    }
}

IntegerGroup::GroupElement IntegerGroup::identity() const
{
    // IntegerGroup consists of all integers in [0, n-1], and identity is 0
    return this->elements[0];
}

// this group is simply the integers mod n, and should be populated integers in [0,n-1]
// thus, multiplication is simply a matter of returning the element at index (a+b)%n
IntegerGroup::GroupElement IntegerGroup::GroupElement::operator*(const IntegerGroup::GroupElement& b)
{
    // if the group is not defined
    if (!this->group)
        // we simply perform integer multiplication
        return GroupElement(this->val() * b.val());
    // otherwise, perform group multiplication
    return GroupElement((this->val() + b.val()) % this->group->size());
}

IntegerGroup::GroupElement IntegerGroup::GroupElement::operator*=(const IntegerGroup::GroupElement& b)
{
    return ((*this) = (*this) * b);
}

bool IntegerGroup::GroupElement::operator==(const IntegerGroup::GroupElement& b)
{
    return this->m == b.m;
}

bool IntegerGroup::GroupElement::operator!=(const IntegerGroup::GroupElement& b)
{
    return !(*this == b);
}

int IntegerGroup::GroupElement::val() const { return this->m; }

int IntegerGroup::size() const { return this->n; }

Array.cpp，Array.h只是模板化的包装类。它的代码也已经有效了。您可以在此处找到on GitHub的文件，也可以使用std::vector。（现在我刚想到，我现在能做到这一点。）

问题

当我尝试创建IntegerRing并进行编译时，我遇到了无数奇怪的错误，其中大部分与使用私有类数据的类自身函数有关。

到目前为止，我的实现是IntegerRing：

IntegerRing.h

#ifndef INTEGERRING_H
#define INTEGERRING_H

#include "IntegerGroup.h"
#include "Operators.h"

class IntegerRing : public IntegerGroup
{
    public:
        class Element : public IntegerGroup::GroupElement
        {
            public: 
                using IntegerGroup::GroupElement;
                /*Element();
                Element(int);
                Element(int, IntegerRing*);
                ~Element();*/
                operator IntegerGroup::GroupElement() { return IntegerGroup::GroupElement(); }
                Element(const IntegerGroup::GroupElement& el)
                {
                    // copy everything from el into *this
                    this->m = el.m;
                    this->group = el.group;
                }
                /*Element operator+(const Element&);
                Element operator-(const Element&);
                Element operator*(const Element&);
                Element operator+=(const Element&);
                Element operator-=(const Element&);
                Element operator*=(const Element&);*/

        };
        Element identity(Operators);
    private:

};

#endif

IntegerRing.cpp

#include "IntegerRing.h"
#include "IntegerGroup.h"
#include "Operators.h"

/*IntegerRing::Element::Element()
{

}*/

/*IntegerRing::Element(const IntegerGroup::GroupElement& el)
{
    // copy everything from el into *this
    this->m = el.m;
    this->group = el.group;
}
/*
IntegerRing::Element IntegerRing::Element::operator+(const IntegerRing::Element& b)
{
    // IntegerRing is simply Abelian group under addition
    // thus, we treat the elements like group elements first, multiply under that group, and cast to ring elements
    return (IntegerRing::Element)(((IntegerGroup::GroupElement)(*this)) * ((IntegerGroup::GroupElement)b));
}

IntegerRing::Element IntegerRing::Element::operator-(const IntegerRing::Element& b)
{
    int val;
    // if this has a group
    if (this->group)
    {
        // compute (this->m - b.m) % this->group->size()
        val = (this->m - b.m) % this->group->size();
        // if that value is negative, add this->group->size() to it
        if (val < 0) val = this->group->size() + val;
    }
    // otherwise, val is simply the integer difference of this->m,b.m
    else val = this->m - b.m;
    // return element with this value
    return Element(val);
}

IntegerRing::Element IntegerRing::Element::operator*(const IntegerRing::Element& b)
{
    if (this->group)
        return IntegerRing::Element((this->m - b.m) % this->group->size());
    return IntegerRing::Element(this->m - b.m);
}

IntegerRing::Element IntegerRing::Element::operator+=(const IntegerRing::Element& b)
{
    return ((*this) = (*this) + b);
}

IntegerRing::Element IntegerRing::Element::operator-=(const IntegerRing::Element& b)
{
    return ((*this) = (*this) - b);
}

IntegerRing::Element IntegerRing::Element::operator*=(const IntegerRing::Element& b)
{
    return ((*this) = (*this) * b);
}
*/
IntegerRing::Element IntegerRing::identity(Operators op)
{
    // if op is ADDITIVE
    if (op == ADDITIVE)
        // return what the base version of this method would return
        return (IntegerRing::Element)(((IntegerGroup::GroupElement*)this)->identity());
    // multiplicative identity requested, and it is 1
    return (IntegerRing::Element)this->elements[0];
}

Operators.h

#ifndef OPERATORS_H
#define OPERATORS_H

enum Operators
{
    ADDITIVE, MULTIPLICATIVE
};

#endif

编译器认为IntegerRing::Element的复制构造函数实际上是一个返回int的函数。

错误屏幕截图

以下是错误的屏幕截图：

如何解决所有问题？

Answer 1

原因是您无法访问类的私有字段。继承/嵌套类不会改变它。（异常是内部类总是可以访问它的封闭类的任何成员（自C ++ 11起））

对于using IntegerGroup::GroupElement;中日志usingIntegerGroup::GroupElement::GroupElement;中的第一个错误，IntegerRing::Element内的{{1}}，顺便说一下，我认为不需要这个类。

Answer 2

事实证明，我多年没有像这样使用C ++进行严肃的OOP，这让我忘记了事情。第一个：派生类可以访问protected，public成员，而不是private，除非您在基类中声明派生类a friend。

第二：如何编写复制构造函数。遗憾的是，派生类可以访问自己继承的protected数据成员，而不是基类。为了解决这个问题，我只是写这样的复制构造函数：

IntegerRing::Element::Element(const IntegerGroup::GroupElement::GroupElement& el)
 : IntegerGroup::GroupElement(el)
{

}

派生内部类的成员

2 个答案: