分配运算符实现的说明

Explanation of assignment operator implementation

本文关键字：说明 实现 运算符 分配      更新时间：2023-10-16

有人能向我解释一下这个方法/函数的作用吗？

Bank& Bank::operator=(const Bank& bank) throw() {
    // Zuweisung auf mich selbst?
    if (this == &bank)
        return *this;
    // bisherige Konto-Objekte destruieren
    loescheKonten();
    // Attribute uebertragen und das Array anlegen
    this->name = bank.name;
    this->maxAnzKonten = bank.maxAnzKonten;
    kontoTab = new Konto*[maxAnzKonten];
    anzKonten = bank.anzKonten;
    // vorhandene Konten kopieren
    for (int i = 0; i < anzKonten; i++) {
        Konto* tmp = bank.kontoTab[i];
        kontoTab[i] = new Konto(*tmp);
    }
    return *this;
}

尤其是这个：

Bank& Bank::operator=(const Bank& bank) throw() {
    // Zuweisung auf mich selbst?
    if (this == &bank)
        return *this;

什么是Bank::operator=(const Bank& bank) ...

银行构造函数是否将银行类银行分配给运算符变量？或者如何？操作员类型为Bank？

这个特殊部分处理自分配。通常情况下，这是赋值运算符中的代码存在问题的迹象，例如缺乏异常安全性。

典型的情况是当您有一个具有动态分配数据的类时，例如：

class X { 
    char *whatever;
    size_t size;
public:
    X &operator=(X const &other) { 
        delete [] whatever;
        size = other.size;
        whatever = new char [other.size];       
        for (int i=0; i<size; i++)
            whatever[i] = other.whatever[i];
    }
};

在自分配的情况下，这将在复制源中的数据之前删除目标中的数据。如果源和目标相同，则删除数据会破坏对象。

为了防止这种情况，有一段时间，这是典型的，包括一开始的条件，就像你展示的那样：

if (this == &other)
   return *this;

所以自我分配并没有破坏你的数据。然而，如上所述，面对例外情况，这是不安全的。为了异常安全，您通常希望创建源的副本，然后将其内容交换到目标中。在这种情况下，检查自分配可以作为一种优化，但对于正确的操作来说不再是必要的（至少根据我的经验，这也是一种相当没有价值的优化）。

这是一个复制赋值运算符。您感到困惑的代码部分是检查以确保this指针与传递到函数中的引用不同。例如：

Bank b;
b = b;

引用检查通过尝试将第二行的数据分配给它自己来防止它引起问题（特别是，当你只是将自己设置为自己时，没有必要重新分配动态内存，所以它避免了所有这些）。

有人能向我解释一下这个方法/函数在做什么吗？

它为Bank类实例分配提供了一个特别不安全的实现。该实现是不安全的，因为它可能引发异常，而函数被标记为throw()。默认情况下，如果在内存不足的情况下运行此代码（分配失败），则应用程序将调用terminate并退出。

尤其是这个：

Bank& Bank::operator=(const Bank& bank) throw() {
    // Zuweisung auf mich selbst?
    if (this == &bank)
        return *this;

Bank:：operator=（constBank&Bank）。。。

这声明了一个函数，该函数返回Bank引用并获取对Bank实例的常量引用。这个函数是一个赋值操作，也就是说你这样称呼它：

Bank a, b;
a = b; // same as a.operator=(b);

if语句检查this指针是否与参数不同，因为这种情况会使应用程序经历未定义的行为。

第一个阻止自分配，如下所示：

Bank a;
a = a;

=运算符和其他类函数一样，但它被伪装成=。当表达式a = b;内部的a和b都属于Bank类型时，将调用它。

这就是定义的含义：

Bank& Bank::operator=(const Bank& bank)；第一个Bank::指的是a = b;中左操作数的类型，参数const Bank& bank指的是b。这与其他任何函数参数一样。

此外，Bank&是表达式a = b的返回值，在这种情况下，它将返回a如果您愿意，您不需要返回任何内容（使用void），但在这种情况下，您将无法执行a = b = c，因为b = c返回void，并且a = something_void 没有相等的运算符

它基本上覆盖了类型为Bank的对象的=运算符，允许这样做：

Bank A;
Bank B;
.
.
.
A = B;

线路

if (this == &bank)
    return *this;

将参数的指针值与当前实例进行比较，以查看它们是否是同一对象。如果它们是，那么就没有工作要做，因为你正在将对象指定给它自己。

该方法返回this作为非常量引用（Bank&）的原因是，在处理基本类型（如doubles、int、chars）时，以下是有效的c++语法：

(A = B) = C; //sic

而且，让重写的运算符像处理基本类型一样工作被认为是一种很好的形式。

相关文章：