Question

如何在C ++中编写此记录和过程？如何将代码转换为类和方法而不是直接翻译？

type
complex=record
im,re:real;
end;

procedure NumberMultiplication(a:complex; var b:complex; k:byte);
  begin
    b.re:=a.re*k;
    b.im:=a.im*k;
  end;

Answer 1

C ++标准库已经提供了此功能。

包含标题<complex>，使用类型std::complex<double>，表达与普通*的乘法。

示例：

#include <complex>

using Complex   = std::complex<double>;
using Byte      = unsigned char;

auto operator*( Byte const b, Complex const& c )
    -> Complex
{ return Complex( b )*c; }

#include <iostream>
using namespace std;
auto main() -> int
{
    Byte const      b = 42;
    Complex const   c = {2, 3};         // 2 + 3*i

    cout << b*c << endl;
}

Answer 2

在C ++中，您可以：

struct complex {
    double im, re;
};

该程序可以写成：

void NumberMultiplication(complex a, complex &b, byte k)
{
    b.re = a.re * k;
    b.im = a.im * k;
}

这是Pascal实现的直接翻译;也许有更好的方法可以用C ++编写它，具体取决于你的总体目标。

Answer 3

您可以定义自己的结构

struct complex
{
 double re, im;
}

void NumberMultiplication(const complex a; complex &b, short int k)
{
  b.re = a.re * k;
  b.im = a.im * k;
}

（为什么字节 - 短int类型???）。

我更喜欢更好的方法，即

#include <complex>

std::complex<double> a, b; 
short int k;  
b = a * k;

（仍被短篇小说困惑）。您可以在http://www.cplusplus.com/reference/complex/

查看复杂的类引用

Answer 4

如前所述，最直接的翻译是用record替换Pascal struct。请注意，byte的C ++等效项为unsigned char，因此最直接的翻译是：

struct complex
{
  double re, im;
};

void NumberMultiplication(complex a, complex& b, unsigned char k)
{
   b.re = a.re*k;
   b.im = a.im * k;
}

但是，这不是最好的翻译。首先要提到的是，与Pascal不同，C ++允许返回结构化类型（我认为也有Pascal方言允许这样做）。因此，您可以将NumberMultiplication更改为返回complex的函数：

complex NumberMultiplication(complex a, unsigned char k)
{
  complex b { a.re*k, a.im * k };
  return b;
}

请注意，在上面的代码中，我使用了在本地变量定义中直接初始化C ++ struct的可能性。但是，通过赋予complex构造函数，您可以做得更好：

struct complex
{
  double re, im;
  complex(double real, double imag = 0); // constructor declaration
};

// inline is a hint for the compiler to optimize by inserting that code
// into calling code
inline complex::complex(double real, double imag):
  re(real),
  im(imag)   // these initialize the members
{
  // here you could write other code to be executed on initialization
  // (not needed in this case)
}

complex NumberMultiplication(complex a, unsigned char k)
{
  return complex(a.re * k, a.im * k);
}

请注意，构造函数（double imag）的第二个参数有一个默认参数（= 0）;这可以省略虚部;此外，既然现在可以只使用一个参数调用构造函数（并且没有标记为explicit），这也可以使隐式转换为double，也就是说，您现在可以编写例如。

complex z = NumberMultiplication(3.0, 7);

这与

相同

complex z = NumberMultiplication(complex(3.0, 0.0), 7);

下一个改进是使用C ++的运算符重载：没有必要为我们通常使用乘法运算符*的运算创建一个奇特的函数名称。 ;我们可以通过使用特殊函数名operator*：

为我们自己的类型定义乘法运算符

complex operator*(complex a, unsigned char k)
{
  return complex(a.re * k, a.im * k);
}

你现在可以简单地写e。克。

complex x(1,2), y;
unsigned char c = 42;
y = x*c;

当然，您有时也可能希望编写y=c*x，并希望它也能正常工作。幸运的是，由于函数重载，你可以做到这一点：只需添加

complex operator*(unsigned char k, complex a)
{
  return complex(a.re * k, a.im * k);
}

并且编译器将从类型中选择要调用的正确函数。

接下来，我们可以通过隐藏成员变量来改进complex结构，使其成为一个合适的类。我们提供访问器功能来读取实部和虚部。所以我们现在得到：

class complex
{
public:
  complex(double real, double imag=0);
  double real();
  double imag();
};

inline complex::complex(doube real, double imag):
  re(real),
  im(imag)
{
};

inline double complex::real()
{
  return re;
}

inline double complex::imag()
{
  return im;
}

complex operator*(complex a, unsigned char k)
{
  return complex(a.real() * k, a.imag() * k);
}

complex operator*(unsigned char k, complex a)
{
  return complex(a.real() * k, a.imag() * k);
}

现在复杂的数字当然需要比乘法更多的操作;但幸运的是，你可以节省自己所有的工作，因为有人已经为你做了。在C ++中存在标题complex，其中包含复数的完整实现。因此你可以写

#include <complex>

并在Pascal代码使用自定义std::complex<double>类型的任何地方使用类型complex。

Answer 5

我会用以下方式解释它

strcut complex
{
   double im;
   double re;
};


complex operator *( const complex &c, int k )
{
   return { k * c.im, k * c.re };
}   

complex operator *( int k, const complex &c )
{
   return { k * c.im, k * c.re };
}

即操作将是可交换的。你可以写

complex c = { 1, 2 };

c = 3 * c;

c = c * 3;

或者如果您的编译器不支持初始化列表，那么

strcut complex
{
   double im;
   double re;
};


complex operator *( const complex &c, int k )
{
   complex tmp = { k * c.im, k * c.re };

   return tmp;     
}   

complex operator *( int k, const complex &c )
{
   complex tmp = { k * c.im, k * c.re };

   return tmp;     
}

我如何将这个Pascal部分解释为C ++？

5 个答案: