0

我知道有两个问题：

我不知道如何正确重载运算符（在这种情况下是括号）。我希望运算符重载调用私有成员函数'isprime::path'。什么是正确的方法？

我不断收到有关在主函数中使用 isprime 类成员函数“isprime::start”的错误消息，显然是因为它缺少对象，这对我来说似乎不真实。

#include <iostream>
#include <cstdlib>
#include <vector>
using namespace std;

 class isprime{
    public:
        isprime();
        void start(int thing);
        bool test(int target);
        void check(int x);
        void path(int targ);
        void checktwo(int xtwo);

        operator()(int p);

    private:
        vector<int> testing;
        int b;
};

int main ()
{
    int given;

    while(cin>>given)
    {
        isprime::start(given);//check input as long as there is input
    }
    return 0;
}

void isprime::start(int thing)
{
    if(test(thing) == 1)
    {
        cout<<thing<<" is a prime number.";
    }
    else
    {
        check(thing);
    }
}

isprime::isprime()
{
    testing[0] = {2};
    b = 0;
}

void isprime::check(int x)//checks if input is prime, and sets up next step if so
{
    int s;
    if(x == 0 || x == 1 || x == -1 || x == 2 || x == -2)
    {
        cout<<x<<" is a prime number.";
    }
    else
    {
        for(int i = 2; i < x; i++)
        {
            s = x % i;
            if(s == 0)
            {
                b = 1;
                break;
            }
        }
        if(s != 0)
        {
            cout<<x<<" is a prime number.";
        }
        path(x);
    }
}

bool isprime::test (int target)//see if input is already in list
{
    for(int i = 0; i < testing.size(); i++)
    {
        if(target == testing[i])
        {
            return 1;
        }
    } 
    if(int i = testing.size() && target != testing[i])
    {
        return 0;//if not in list, must test whether it is prime
    } 
}

void isprime::path(int targ)
{
    int y = testing.back() + 1;
    while(y != targ)//find all primes between list end and input
    {
        checktwo(y);
        y++;
    }

    testing.push_back(targ);//add prime input to vector

    int storage = testing.size();//remember size
    int z = targ + 1;

    while(b = 1)//find the next prime while the target isn't prime
    {
        checktwo(z);
        if(testing.size() != storage)//if the size changed, the next prime has been found
        {
            break;
        }
        z++;
    }
}
void isprime::checktwo(int xtwo)//modified check function to add prime numbers between the vector end and the input to the vector
{
    int s;
    if( xtwo == -2 || xtwo == -1 || xtwo == 0 || xtwo == 1 || xtwo == 2)
    {
        testing.push_back(xtwo);
    }
    else
    {
        for(int i = 2; i < xtwo; i++)
        {
            s = xtwo % i;
            if(s == 0)
            {
                break;
            }
        }
        if(s != 0)
        {
            testing.push_back(xtwo);
        }
    }
} 

operator()(const int p)
{
    test(p);//calls a private member function to expand list of prime numbers (test)
}
4

3 回答 3

1

  1. 当你声明operator ()你需要指定一个返回类型。

  2. 当您定义它时，您需要符合条件isprime

  3. 当你打电话时，start你需要一个对象

于 2013-10-02T15:13:11.240 回答
0

两个变化。在声明中isprime

bool operator()( const int p );

在定义中：

bool isprime::operator()( const int p )
{
    return test(p);
}

编辑：如下所述。要调用成员函数（非静态），您必须拥有该类型的对象。

int main ()
{
    int given;
    isprime prime_object;

    while(cin>>given)
    {
        prime_object.start(given);//check input as long as there is input
    }
    return 0;
}
于 2013-10-02T15:15:27.773 回答
0

函数调用运算符是类 isprime 的成员，因此您应该指出：

bool isprime::operator()(const int p)
{
    return test(p);
}

您编写代码的方式无法知道运算符是isprime. 另外不要忘记为我推断的该运算符指定返回类型，它应该是 bool ，这就是我上面使用的类型。

您得到的第二个错误是因为您尝试使用没有实例的实例方法。要么创建一个实例isprime并调用它的方法，要么将 start 声明为静态。据我所知，我猜你需要一个实例。

于 2013-10-02T15:13:34.903 回答