在C++中用常数乘以复数

Question

在C++中用常数乘以复数

c++operatorscomplex-numbersmultiplication

9

以下代码无法编译。

#include <iostream>
#include <cmath>
#include <complex>

using namespace std;

int main(void)
{
    const double b=3;
    complex <double> i(0, 1), comp;

    comp = b*i;

    comp = 3*i;

    return 0;
}

出错了：在“3 * i”中没有匹配的“operator*”。为什么我不能与立即常量相乘？ b*i可以。

- Atilla Filiz

3个回答

7

在第一行中：

comp = b*i;

编译器调用：

template<class T> complex<T> operator*(const T& val, const complex<T>& rhs);

这个实例是这样的:

template<> complex<double> operator*(const double& val, const complex<double>& rhs);

在第二种情况下，没有适当的模板int，因此实例化失败：

comp = 3.0 * i; // no operator*(int, complex<double>)

- greyfade

4

请参阅http://www.cplusplus.com/reference/std/complex/complex/operators/，了解复数运算符的概述。

您会注意到，operator*是一个模板，并将使用复数类的模板参数生成该代码。您用于调用operator*的数字字面值的类型为int。请使用comp = 3. * i;。

- pmr

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- tesch1 · Accepted Answer

std::complex 类有些愚蠢...定义这些允许自动提升：

// Trick to allow type promotion below
template <typename T>
struct identity_t { typedef T type; };

/// Make working with std::complex<> nubmers suck less... allow promotion.
#define COMPLEX_OPS(OP)                                                 \
  template <typename _Tp>                                               \
  std::complex<_Tp>                                                     \
  operator OP(std::complex<_Tp> lhs, const typename identity_t<_Tp>::type & rhs) \
  {                                                                     \
    return lhs OP rhs;                                                  \
  }                                                                     \
  template <typename _Tp>                                               \
  std::complex<_Tp>                                                     \
  operator OP(const typename identity_t<_Tp>::type & lhs, const std::complex<_Tp> & rhs) \
  {                                                                     \
    return lhs OP rhs;                                                  \
  }
COMPLEX_OPS(+)
COMPLEX_OPS(-)
COMPLEX_OPS(*)
COMPLEX_OPS(/)
#undef COMPLEX_OPS