在 C++ 中用 'double' 类型的乘数将复杂对象与实部和虚部相乘

Question

我正在尝试将复杂数组的每个元素乘以一个乘数，以应用傅里叶变换。我正在将汉宁 window 滤波器应用于波函数的复杂文件。

我在 C++ 中使用 CodeBlocks 工作，我不断得到 -->

error: invalid types 'double[int]' for array subscript

我的代码在这里：

#include <iostream>
#include <fstream>
#include <string>
#include <regex>
#include <cmath>
#define PI 3.14159265359
using namespace std;

class Complex {
    public:
        Complex();
        Complex(double realNum);
        Complex(double realNum, double imagNum);

        //Complex(double real = 0.0, double imaginary = 0.0); This avoids the 3 above?
        Complex(const Complex& obj);
    private:
       double real;
       double imaginary;
 };

Complex::Complex(const Complex& obj) {
    real = obj.real;
    imaginary = obj.imaginary;
}

Complex::Complex () {
   real = 0;
   imaginary = 0;
}

Complex::Complex (double realNum) {
    real = realNum;
    imaginary = 0;
}

Complex::Complex (double realNum, double imagNum) {
   real = realNum;
   imaginary = imagNum;
}

int main () {
    Complex *complexArray = new Complex[1000];
    ifstream myfile("myfile.txt");
    /* this will match the complex numbers of the form - 123.123 + 14.1244  or 123 - 1343.193 and so on,
      basically assumes that both the real and the imaginary parts are both doubles*/
    regex reg_obj("^[ ]*([-]?\d+(\.\d+)?)\s*([+-])\s*(\d+(\.\d+)?)i");
    smatch sm;
    string line;
    int i = 0;
    double real, imag;
    if (myfile.is_open()) {
        while (! myfile.eof()) {

            getline(myfile, line);
            if(regex_search(line, sm, reg_obj)){
                real = stod(sm[1]);       // this ([-]?\d+(\.\d+)?) is group 1 and will match the real part of the number
                imag = stod(sm[4]);       // second group (\d+(\.\d+)?)i is group 4 which matches the imaginary part of the complex number without matching + or - which are taken care of separately because there could be space between the +|- symbol and the imaginary part
                if(sm[3]=="-") imag = -imag;
                complexArray[i] = Complex(real, imag);
                i++;
            }
            // Hanning Window
            for (int i = 0; i < 1000; i++) {
                double multiplier = 0.5 * (1 - cos(2*PI*i/999));
                complexArray[i] = multiplier[i] * complexArray[i];
                }
        }

        myfile.close();
     }else {
        cout << "Error. Could not find/open file." ;
     }
     cout << complexArray << endl;
     return 0;
};

我想将复杂对象的每个元素乘以乘法数组中的每个元素。我不确定执行此操作的正确方法。

Answer 1

对于此循环中的初学者

        for (int i = 0; i < 1000; i++) {
            double multiplier = 0.5 * (1 - cos(2*PI*i/999));
            complexArray[i] = multiplier[i] * complexArray[i];
            }

变量multiplier被声明为双精度类型的标量对象。所以你需要写

complexArray[i] = multiplier * complexArray[i];

而不是

complexArray[i] = multiplier[i] * complexArray[i];

您还需要为 class.

重载 operator *

例如

class Complex {
    public:
        Complex();
        Complex(double realNum);
        Complex(double realNum, double imagNum);

        //Complex(double real = 0.0, double imaginary = 0.0); This avoids the 3 above?
        Complex(const Complex& obj);

        friend const Complex operator *( double, const Complex & );
    private:
       double real;
       double imaginary;
};

//...

const Complex operator *( double value, const Complex &c )
{
    return { value * c.real, value * c.imaginary };
}

也是while循环中的条件

    while (! myfile.eof()) {

        getline(myfile, line);
        //...

替代

    while ( getline(myfile, line) ) {
        //...

这个循环

        for (int i = 0; i < 1000; i++) {
            double multiplier = 0.5 * (1 - cos(2*PI*i/999));
            complexArray[i] = multiplier[i] * complexArray[i];
            }

应该在 while 循环之外。例如

        for ( int j = 0; j < i; j++) {
            double multiplier = 0.5 * (1 - cos(2*PI*i/999));
            complexArray[j] = multiplier * complexArray[j];
            }

在 C++ 中用 'double' 类型的乘数将复杂对象与实部和虚部相乘

Multiply complex object with real and imaginary parts by a multiplier of type 'double' in C++

c++

class

operator-overloading

operators

complex-data-types