c++ - 没有在此范围内声明？

Question

度过了一个可怕的夜晚，我是 C++ 的新手，我不太明白自己在做什么。我只是问了一个问题，但我认为这会解决所有问题，任何朝着正确方向的插入都会受到极大的赞赏，甚至只是一个提示。

我想我应该在 main.cpp 中重新声明它们，但这会清除这些值……对吗？[错误位于代码“//Number crunching part”的注释数字运算部分下面的 for 循环中]

直到这里我才几乎解决了这个问题，不幸的是我必须为此发布整个代码我将从遇到的错误开始 -->

`g++ complex.cpp -o complex
complex.cpp: In function ‘int main(int, char**)’:
complex.cpp:157:60: error: ‘getReal’ was not declared in this scope
complex.cpp:158:65: error: ‘getImaginary’ was not declared in this scope
complex.cpp:159:65: error: ‘getMagnitude’ was not declared in this scope
complex.cpp:160:61: error: ‘getPhase’ was not declared in this scope
complex.cpp:162:51: error: ‘getPower’ was not declared in this scope
complex.cpp:163:49: error: ‘getRoot’ was not declared in this scope
complex.cpp:164:41: error: ‘getConjugate’ was not declared in this scope
complex.cpp:171:52: error: ‘add’ was not declared in this scope
complex.cpp:172:57: error: ‘subtract’ was not declared in this scope
complex.cpp:173:57: error: ‘multiply’ was not declared in this scope
complex.cpp:174:55: error: ‘divide’ was not declared in this scope
make: *** [complex] Error 1

这是main.cpp

#include "complex.h"
#include "complex-functions.cpp"    

main(int argc, char *argv[]) 
{
    int here;
    int amountComplex, mRoot, nPower, form, i, j;
    double tempRealorMag, tempImagorPhase, userInput1, userInput2;
    COMPLEX::complex secondnumber, atemp, stemp, mtemp, dtemp, ptemp, rtemp, ctemp;

    FILE *inputf; //Pointer to the input filepath
    FILE *outputf; //Pointer to the output filepath

    switch (argc)
    {
        case 2:
            fprintf( stderr,"Error: Please also provide an output filename\n");
            return(1);
        case 3:
            break; // have input file and output file; all is OK
        default:
            fprintf( stderr,"Error: Please provide input and output filenames respectively as command line arguments\n");
            return(1);
    }

    if((inputf=fopen(argv[1],"r"))==NULL)
    {
        fprintf(stderr,"Error opening input file file. Check permissions.\n");
        return(1);
    }

    if((outputf=fopen(argv[2],"w"))==NULL)
    {
        fprintf(stderr,"Error opening output file. Check permissions.\n");
        return(1);
    }

// read the first four numbers from the text file

    fscanf(inputf, "%d",  &amountComplex);
    fscanf(inputf, "%d",  &form);
    fscanf(inputf, "%d",  &nPower);
    fscanf(inputf, "%d",  &mRoot);

    if (form != 1, 0) 
    {
        cout <<"Number must be in Cartesian or Polar format  ONLY\n";
        return(1);
    }

    if (amountComplex <= 0)
    {
        cout <<"Number of complex computations must be above zero.\n";
        return (1);
    }

   COMPLEX:: complex myCarray[amountComplex];

// reads the numbers and puts them into an array; closes inputfile

    for (i = 0; i < amountComplex; i++)
    {
        fscanf(inputf, "%lf",  &tempRealorMag);
        fscanf(inputf, "%lf",  &tempImagorPhase);
        myCarray[i].real = tempRealorMag;
        myCarray[i].imaginary = tempImagorPhase;
    }
    fclose(inputf);


// enters the second the number to be added, can be in
// cartesian (0) or polar (1) formats 

// cartesian format
    if (form == 0)
    {
        cout << "\nEnter real part of your number: ";
        cin >>   userInput1;
        cout << "\nEnter imaginary part of your number" ;
        cin >>   userInput2;
        secondnumber.real = userInput1;
        secondnumber.imaginary = userInput2;
    }

// polar format
    if (form == 1)
    {
        cout <<"\nEnter Magnitude of your number: ";
        cin >>  userInput1;
        cout <<"\nEnter Phase of your number: ";
        cin >>  userInput2;
        secondnumber.real = userInput1; 
        secondnumber.imaginary = userInput2;
    }    

// writes results    
// cartesian format
    if(form == 0)
    {
        fprintf(outputf, "This will be in Cartesian format, the order of results are:\n"
            "Real part\nImaginary part\nMagnitude\nPhase\nPower\nRoot\nConjugate\n"
            "Addition\n"Subtraction\nMultiplication\nDivision\n\n");
    }
// polar format
    if(form == 1)
    {
        fprintf(outputf, "This will be in Polar format, the order of results are:\n"
            "Real part\nImaginary part\nMagnitude\nPhase\nPower\nRoot\nConjugate\n"
            "Addition\nSubtraction\nMultiplication\nDivision\n\n");
    }

// number crunching part of code    
    for(j = 0; j < amountComplex; j++)
    {
// Real part, Imaginary part, Magnitude, Phase, Power, Root, 
// and Conjugate of complex number input array
        fprintf(outputf, "%lf\n", getReal(myCarray[j], form));
        fprintf(outputf, "%lf\n", getImaginary(myCarray[j], form));
        fprintf(outputf, "%lf\n", getMagnitude(myCarray[j], form));
        fprintf(outputf, "%lf\n", getPhase(myCarray[j], form));

        ptemp = getPower(nPower, myCarray[j], form);
        rtemp = getRoot(mRoot, myCarray[j], form);
        ctemp = getConjugate(myCarray[j]);

        fprintf(outputf, "%lf %lf \n", ptemp.real, ptemp.imaginary);
        fprintf(outputf, "%lf %lf \n", rtemp.real, rtemp.imaginary);
        fprintf(outputf, "%lf %lf \n", ctemp.real, ctemp.imaginary);

// Addition, Subtraction, Multiplication, Division with Second Number entered by user
        atemp = add(myCarray[j], secondnumber, form);
        stemp = subtract(myCarray[j], secondnumber, form);
        mtemp = multiply(myCarray[j], secondnumber, form);
        dtemp = divide(myCarray[j], secondnumber, form);

        fprintf(outputf, "%lf %lf \n", atemp.real, atemp.imaginary);
        fprintf(outputf, "%lf %lf \n", stemp.real, stemp.imaginary);
        fprintf(outputf, "%lf %lf \n", mtemp.real, mtemp.imaginary);
        fprintf(outputf, "%lf %lf \n", dtemp.real, dtemp.imaginary);

        fprintf(outputf, "\n\tNext Complex Number");
    }
    fclose(outputf);

} //end of main function

它正在调用一个驱动程序和一个函数文件驱动程序 -->

    #ifndef COMPLEX_H
    #define COMPLEX_H
    #include<iostream>
    #include<fstream>
    #include<string>
    #include<vector>
    #include<iomanip>
    #include<cmath>

    using namespace std;

    class COMPLEX
    {
    public:
        typedef struct{
            double real;
            double imaginary;       
                }complex;

            double getReal(complex n, int form );
            double getImaginary(complex n, int form);
            double getMagnitude(complex n, int form);
            double getPhase(complex n, int form);
            complex add(complex n, complex m, int form);
            complex subtract(complex n, complex m, int form);
            complex multiply(complex n, complex m, int form);
            complex divide(complex n, complex m, int form);
            complex getConjugate(complex n);
            complex getPower(int npower, complex n, int form);
            complex getRoot(int mroot, complex n, int form);
            complex changeToCart(complex n);
            complex changeToPolar(complex n);
    };
    #endif`

FUNCTION FILE-->
`
    #include "complex.h"
    //returns the real part of the complex number
    double COMPLEX :: getReal(complex n, int form)
    {
     if(form == 0)
        return(n.real);
     if(form == 1)
     {
        complex temp = changeToCart(n);
        return(temp.real);
     }
    }

    //returns the imaginary part of the complex number
    double COMPLEX ::  getImaginary(complex n, int form)
    {
     if(form == 0)
        return(n.imaginary);
     if(form == 1) 
        return((n.real * sin(n.imaginary)));

    }

    //returns the magnitude of the complex number
    double COMPLEX ::  getMagnitude(complex n, int form)
    {
     if(form == 0)
     {
        float x = n.real;
        float y = n.imaginary;
        return(sqrt((x * x + y * y)));
     }
     if(form == 1)
        return(n.real);
    }

    //returns the phase of the complex number
    double COMPLEX ::  getPhase(complex n, int form)
    {
     if(form == 0)
     {
        float x = n.real;
        float y = n.imaginary;
        return(atan2(y,x));
     }
     if(form == 1)
     {
        return(n.imaginary);
     }
    }

    //adds two complex numbers together
    COMPLEX::complex COMPLEX::add(COMPLEX::complex n, COMPLEX::complex m, int form)
    {
        complex temp, temp2, temp3;
     if(form == 0)
     { 
        temp.real = n.real + m.real;
        temp.imaginary = n.imaginary + m.imaginary;
        return(temp);
     }
     if(form == 1)
     {
        temp3.real = (n.real*cos(n.imaginary) + m.real*cos(m.imaginary));
        temp3.imaginary = (n.real*sin(n.imaginary) + m.real*sin(m.imaginary));
        temp2.real = getMagnitude(temp3, 0);
        temp2.imaginary = getPhase(temp3, 0);
        return(temp2);
     }
    }

    //subtracts one complex number from another
    COMPLEX::complex COMPLEX::subtract(COMPLEX::complex n, COMPLEX::complex m, int form)
    {
        complex temp, temp2;
     if(form == 0)
     {
        temp.real = n.real - m.real;
        temp.imaginary = n.imaginary - m.imaginary;
        return(temp);
     }
     if(form == 1)
     {
        temp.real = (n.real*cos(n.imaginary) - m.real*cos(m.imaginary));
        temp.imaginary = (n.real*sin(n.imaginary) - m.real*sin(m.imaginary));
        temp2.real = getMagnitude(temp, 0);
        temp2.imaginary = getPhase(temp, 0);
        return(temp2);
     }
    }

    //multiplies two complex together
    COMPLEX::complex COMPLEX::multiply(COMPLEX::complex n, COMPLEX::complex m, int form)
    {
        complex temp;
     if(form == 0)
     {
        float r1 = getMagnitude(n, 0);
        float r2 = getMagnitude(m, 0);
        float ang1 = getPhase(n, 0);
        float ang2 = getPhase(m, 0);
        float r3 = r1 * r2;
        if(r3 == 0)
        {
         temp.real = 0.0;
         temp.imaginary = 0.0;
         return(temp);
        }
        else
        {
         float ang3 = ang1 + ang2;
         temp.real = r3*cos(ang3);
         temp.imaginary = r3*sin(ang3);
         return(temp);
        }
     }
     if(form == 1)
     {
        if(n.real == 0 || m.real == 0)
        {
         temp.real = 0.0;
         temp.real = 0.0;
         return(temp);
        }
        else
        {
         temp.real = n.real * m.real;
         temp.imaginary = n.imaginary + m.imaginary;
         return(temp);
        }
     }
    }

    //divides one complex number by another
    COMPLEX::complex COMPLEX::divide(COMPLEX::complex n, COMPLEX::complex m, int form)
    {
        complex temp;
    if(form == 0)
    {
      if(getMagnitude(m, form) != 0)
     {

        float r1 = getMagnitude(n, 0);
        float r2 = getMagnitude(m, 0);  
        float ang1 = getPhase(n, 0);
        float ang2 = getPhase(m, 0);
        float r3 = r1 / r2;
        float ang3 = ang1 - ang2;
        temp.real = r3*cos(ang3);
        temp.imaginary = r3*sin(ang3);
        return(temp); 
     }
    }
    else
    {
        cout <<"Sorry, you can't divide by zero, instead, both parts will be shown as -1.337.\n";
        temp.real = -1.337;
        temp.imaginary = -1.337;
        return(temp);
    }
     if(form == 1)
     {
      if(m.real =! 0)
      {
        temp.real = n.real/m.real;
        temp.imaginary = n.imaginary - m.imaginary;
        return(temp);
      }
     }
     else
     {
        cout << "Sorry, but you can't divide by zero, instead, both parts will be shown as -1.337.\n";
        temp.real = -1.337;
        temp.imaginary = -1.337;
        return(temp);
     } 
    }

    //takes the nth power of a complex number
    COMPLEX::complex COMPLEX::getPower(int npower, COMPLEX::complex n, int form)
    {
        complex temp;
     if(form == 0)
     {
        float r1 = getMagnitude(n, 0);
        float ang1 = getPhase(n, 0);
        float r2 = pow(r1, npower);
        float ang2 = npower * ang1;
        temp.real = r2*cos(ang2);
        temp.imaginary = r2*sin(ang2);
        return(temp);
     }
     if(form == 1)
     {
        temp.real = pow(n.real, npower);
        temp.imaginary = npower * n.imaginary;
        return(temp); 
     }
    }

    //takes the mth root of a complex number
    COMPLEX :: complex COMPLEX::getRoot(int mroot, COMPLEX::complex n, int form)
    {
        complex temp;
     if(form == 0)
     {
        float r1 = getMagnitude(n,0);
        float ang1 = getPhase(n,0);
        float r2 = pow(r1, 1.0/mroot);
        float ang2 = ang1/mroot;
        temp.real = r2*cos(ang2);
        temp.imaginary = r2*sin(ang2);
        return(temp);
     }
     if(form == 1)
     {
        temp.real = pow(n.real, 1.0/mroot);
        temp.imaginary = n.imaginary/mroot;
        return(temp);
     }
    }

    //returns the conjugate of a complex number
    COMPLEX :: complex COMPLEX::getConjugate(COMPLEX::complex n)
    {
        float iman = n.imaginary * -1;
        complex temp = {n.real, iman };
        return(temp);
    }

    //changes a complex number to cartesian form
    COMPLEX :: complex COMPLEX::changeToCart(COMPLEX::complex n)
    {
        float rtemp = n.real;
        float ptemp = n.imaginary;
        float realtemp = rtemp * cos(ptemp);
        float imantemp = rtemp * sin(ptemp);
        complex temp = {realtemp, imantemp};
        return(temp);
    }

    //changes a complex number to polar form
     COMPLEX :: complex COMPLEX::changeToPolar(COMPLEX::complex n)
    {
        complex temp;
        temp.real =  getMagnitude(n, 0);
        temp.imaginary = getPhase(n, 0);
        return(temp);
    }

**请注意，当我将 COMPLEX:: 放在作用域错误函数的前面时，我在编译时会遇到此错误 -->

 error: cannot call member function ‘COMPLEX::complex COMPLEX::add(COMPLEX::complex, COMPLEX::complex, int)’ without object

Answer 1

您正在调用的函数是 class COMPLEX 中的类函数。您需要通过该类的实例调用它们，或者(如果它们是 static 函数)通过​​限定命名空间:COMPLEX::getReal

如果您想使用 COMPLEX::getReal 调用它们，则需要将它们声明为 static - 此时它们将无法访问成员数据。