이 파스칼 파트를 C++로 어떻게 해석합니까?

Question

C++에서이 레코드와 프로 시저를 어떻게 작성합니까? 직접 번역 대신 클래스와 메소드로 코드를 어떻게 변환합니까?

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

, 그럴 수 :

절차는 다음과 같이 쓸 수있다

struct complex { 
    double im, re; 
}; 

:

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

이것은 파스칼의 구현에서 직접 번역 한 것입니다; 아마도 전체적인 목표에 따라 C++로 작성하는 것이 더 좋은 방법 일 것입니다.

Answer 2

C++ 표준 라이브러리는 이미이 기능을 제공합니다.

일반 *와 유형 std::complex<double>, 고속 곱셈을 사용, 헤더 <complex>를 포함합니다.

예 :

#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 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 타입 ???).

나는 (여전히 짧은 INT에 의해 당황)

#include <complex> 

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

에있는 더 나은 방법을 선호합니다. 당신은 내가 그것을 작업이 교환 법칙이 성립 될 것입니다 다음과 같은 방법

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 }; 
} 

를 해석 할 http://www.cplusplus.com/reference/complex/

Answer 4

에서 복잡한 클래스 참조를 확인할 수 있습니다. 당신은

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;  
} 

Answer 5

바와 같이 이미 언급 된 이니셜 라이저 목록을 지원하지 않는 경우, 가장 직접적인 번역은 struct와 파스칼 record을 교체하는 것입니다. 그러므로 가장 직접적인 번역 될 것이라고 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; 
} 

그러나, 이것은 최선의 번역이 아닙니다. 언급 할 첫 번째 것은 파스칼과 달리 C++은 구조화 된 유형을 반환 할 수 있다는 것입니다. (나는 이것을 허용하는 파스칼 방언이 있다고 생각합니다). 따라서 당신은 complex 반환 함수에 NumberMultiplication을 변경할 수 있습니다

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

참고 위의 코드에서, 나는 지역 변수 정의를 직접 C++ struct를 초기화 할 수있는 가능성을 사용한 적이있다.당신은 complex에게 생성자를 제공함으로써 더 나은 할 수 그러나 : 생성자 (double imag)의 두 번째 인수는 기본 인자 (= 0)가 있는지

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); 
} 

참고; 이것은 허수 부를 생략 할 수있게한다; 또한 생성자가 하나의 인수만으로 호출 될 수 있으므로 (explicit으로 표시되지 않음) 암시 적 변환을 두 번으로 수행 할 수 있습니다. 즉, 이제 예를 들어 다음과 같이 작성할 수 있습니다. 우리가 일반적으로 곱셈을 사용하는 것이 작업을위한 멋진 함수 이름을 발명 할 필요가 없습니다 :

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); 
} 

합니다. 지.

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); 
} 

을 추가하고 컴파일러가 타입에서 호출 할 수있는 올바른 기능을 선택합니다 : 다행히 당신은 함수 오버로드 덕분에 있다고 할 수 있습니다.

다음으로 멤버 변수를 숨김으로써 구조체를 올바른 클래스로 만들 수 있습니다. 우리는 실제 및 가상 부분을 읽는 접근 자 함수를 제공합니다. 이제 우리는 다음을 얻습니다 :

이제 복소수는 곱셈보다 훨씬 더 많은 연산이 필요합니다. 다행히도 누군가가 이미 그 일을했기 때문에 자신을 구원 할 수 있습니다. C++에서 복소수의 완전한 구현을 포함하는 complex 헤더가 존재합니다. 따라서 당신은

#include <complex> 

을 쓸 수와 파스칼 코드가 자기 정의 complex 유형을 사용하는 곳 어디에서나 유형 std::complex<double>를 사용합니다.