Можем ли мы написать x ** y на C++ так же, как на Python?

Самый короткий и простой ответ будет ДА!

Второй вопрос: КАК?

Поймите заявление

Утверждение, которое мы пытаемся оценить, выглядит примерно так:

x ** y;

Какие должны быть виды?

Одно можно сказать наверняка; нам нужно перегрузить некоторые операторы. Чтобы перегрузить оператор в C++, он должен принимать как минимум один определяемый пользователем объект в качестве аргумента. При этом либо x, либо y должны быть объектом класса/структура.

Я покажу вам позже, но сейчас, поверьте мне, будет лучше, если этот объект будет вторым аргументом, который в данном случае равен y. Тип x может быть любым примитивным типом, но я предпочитаю double.

Как должен выглядеть этот класс?

класс будет внутренне сохранять double (или любой другой примитивный тип, но лучше использовать double). Давайте посмотрим на этот класс.

class Exponent {
public:
  Exponent(double y) : y{y} {}

private:
  double y;
};

Используя это определение, теперь мы можем создать объект класса Exponent класса и обращаться с ним как с двойником. Давайте теперь создадим объект этого класса.

Как использовать этот класс?

Вот как мы можем создать объект этого класса в main() (или где-либо еще, если на то пошло).

class Exponent {
public:
  Exponent(double y) : y{y} {}

private:
  double y;
};

int main() {
  double x{2.};
  Exponent y{4.};

  auto result{x ** y}; // Won't work yet (of course)

}

Давайте сломаем это

Если присмотреться 🧐, то легко понять, что нам здесь нужно сделать. Я покажу вам, как…

Третья строка в функции main(), где мы вызываем оператор, присмотритесь! Мы также можем написать это как,

auto result{x * *y};

Поскольку C++ не чувствителен к отступам и пробелам, этот код точно такой же, как и выше. К настоящему моменту вам уже должно быть кристально ясно, что мы должны сделать, чтобы это заработало.

Подготовка вещей

Первое, что нам нужно сделать, это перегрузить косвенный оператор Exponent. > класс. Но что бы он сделал🤔? Ну, мы только хотим, чтобы компилятор был доволен тем, что наш класс имеет оператор в этом роде. Нам нужно только отправить объект фактическому оператору (это мы скоро увидим). Давайте посмотрим код. Это будет иметь больше смысла 😁.

class Exponent {
public:
  Exponent(double y) : y{y} {}

  Exponent& operator*() {
    return *this;
  }

private:
  double y;
};

Это определение оператора будет возвращать тот же объект, который мы называем оператором, ничего с этим не делая. Вы также можете определить const версию operator, например,

const Exponent& operator*() const {
    return *this;
  }

Теперь давайте посмотрим, как мы можем реализовать оператор, который принимает двойник и экспонент. strong> и вызывает для них метод std::pow.

// Prototype of the operator
double operator*(double x, Exponent y);

// This should also be made friend of the
// Exponent class because we need to
// access its member 'y'.
class Exponent {
public:
  Exponent(double y) : y{y} {}

  Exponent& operator*() {
    return *this;
  }

private:
  // doesn't have to be private though
  friend double operator*(double x, Exponent y);
  double y;
};

Реализация оператора

Давайте теперь посмотрим весь код с полной реализацией.

#include <iostream>
#include <cmath>

class Exponent {
public:
  Exponent(double y) : y{y} {}

  Exponent& operator*() { return *this; }
  const Exponent& operator*() const { return *this; }

private:
  friend double operator*(double x, Exponent y);
  double y;
};

double operator*(double x, Exponent y) {
  return std::pow(x, y.y);
}

int main() {
  double x{2.};
  Exponent y{4.};

  auto result{x ** y};

  std::cout << "result = " << result << std::endl;

}

Это все, что вам нужно для этого. Он выведет ожидаемый результат.

Что, если мы переставим переменные?

Что, если мы хотим написать код таким образом, чтобы объект Exponent (определяемый пользователем) был первым аргументом, а двойной? em> переменная вторая?

auto result{y ** x}; // What about this one??

int main() {
  double number{2.};
  auto x{&number}; // double*
  Exponent y{4.};

  auto result{y ** x};
}

class Exponent {
public:
  Exponent(double y) : y{y} {}

  double operator*(double y) { return std::pow(this->y, y); }

private:
  friend double operator*(double x, Exponent y);
  double y;
};

#include <iostream>
#include <cmath>

// be better if we renamed it to Base now 😅
class Exponent {
public:
  Exponent(double y) : y{y} {}

  double operator*(double y) { return std::pow(this->y, y); }

private:
  friend double operator*(double x, Exponent y);
  double y;
};

int main() {
  double number{2.};
  auto x{&number};
  Exponent y{4.};

  auto result{y ** x};

  std::cout << "result = " << result << std::endl;
}

int main() {
  double x{2.};
  Exponent y{4.};

  auto result{y ** ((double*)&x)};

  std::cout << "result = " << result << std::endl;
}

int main() {
  double x{2.};
  Exponent y{4.};

  auto result{y ** (&(double&)std::move(2.))};

  std::cout << "result = " << result << std::endl;
}