C++ C++；从3到n的素数

我写这段代码是为了打印用户输入的3到“n”之间的所有素数，但在运行时，它不会产生任何结果

你能帮忙吗

#include <iostream>
using namespace std;

int main()
{
    int n;
    cin >> n;

    for (int candidate = 3; candidate < n; ++candidate)
    {
        bool isPrime = true;
        for (int x = 2; x < n; x++)
        {
            if (candidate % x == 0)
            {
                isPrime = false;
            }
        }

        if (isPrime)
        {
            cout << n << "";
        }
    }
}

#包括
使用名称空间std；
int main（）
{
int n；
cin>>n；
对于（int-candidate=3；candidate不能将您的内部循环从

    for (int x = 2; x < n; x++)
    {
        if (candidate % x == 0)
        {
            isPrime = false;
        }
    }

这将使
candidate
每次递增
2
。这没关系，因为大于2的偶数都不是素数

此外，如果您考虑的数字范围包括
n
，您可以将外部for循环修改为

for (int candidate = 3; candidate < n; candidate+=2)

for（int-candidate=3；candidate

也要考虑<代码> N< /代码>。
 
你应该知道。如果我们检查除法运算是否N是素数，那么你不应该检查超过<代码> SqRT（n）< /C> >
for（int-candidate=3；candidate不建议使用命名空间std；-因为这会从std导入所有标识符。请参阅上的此问题

第二个循环的结束条件是否应该是
candidate
而不是
n
，即

for (int x = 2; x < candidate; x++)//not before N prime numbers divine up to them
{
    if (candidate % x == 0)
        isPrime = false;
}

for（int x=2；x

难道你不应该把
候选人
而不是
n

在你的代码中有几种可能节省效率的方法。最有效的方法（除了使用预先计算的查找表来查找较小的（1，true）；
对于（自动除数=3；除数*除数>1]）
对于（自动候选=除数*除数；候选>1]=假；
std：：向量结果（1,2）；
对于（自动候选=3；候选>1）结果。推回（候选）；
返回结果；
}

此算法的内存访问模式很差（进入
is_prime[]
），这对于非常大的
n
来说是一个问题。一种更复杂的方法，分段筛选，可以避免这种情况，请参见上面的链接。
我认为这应该可行

#include <iostream>
#include <vector>


int main()
{
    //setup start parameters
    //test sequence
    std::vector<int> test_sequence {2};




    int end_number, start_number;
    start_number = 3;
    //take wished end number
    std::cin >> end_number;

    // test is wished number smaler than start number
    if (start_number < end_number)
    {
        // loop which goes trough every number between start and end number
        for (start_number; start_number <= end_number; start_number++)
        {
            bool isPrime = true;
            //test is this number prime
            for (int n = 0; n < test_sequence.size(); n++)
            {
                if (start_number % test_sequence[n] == 0 && start_number != test_sequence[n] )
                {
                isPrime = false;
                }
            }

            if (isPrime)
            {
                std::cout << start_number << std::endl;
                //hold result for next test
                test_sequence.push_back(start_number);
            }
        }

    }
    else
    {
    std::cout << "Wrong input";
    }

}

#包括
#包括
int main（）
{
//设置启动参数
//测试序列
std：：向量测试序列{2}；
int end_编号、start_编号；
起始值=3；
//取所希望的结束号
标准：：cin>>结束编号；
//测试编号小于起始编号
if（开始编号<结束编号）
{
//循环，在起始编号和结束编号之间通过每个编号
for（开始编号；开始编号）您是否尝试过调试它？您是否应该打印出
候选者而不是
n
？for循环应该是x候选者
，还有
的目的是什么
在打印出
n
之后，它是否应该是一个新行或其他空格？顺便说一句：你不需要检查偶数。这是错误的。它只会打印一个素数。他想打印所有的素数。@MartinBonner哦！我还没有意识到。编辑。谢谢你指出。我只会删除旧的错误答案，而不是han保留了它。删除了旧部分在筛选算法中不需要
if
：只需设置
isPrime[j]=false
。这可能比分支更快。但对于简洁的答案，仍然+1=）@Sergey.quixoticaxis.Ivanov事实上，我用
std:：vector
代替了它。令我惊讶的是，代码变慢了（Apple clang编译器，-O3）。奇怪的是，我不知道
char
，但在Intel i5 6600和Intel i7 4790k上，将
：std:：vector
更改为
bool*
（我没有“推回”任何东西和预分配缓冲器对于代码< iSyPrime<代码>只有一次，对MSVC和英特尔C++ 17都有很大的影响。*效果（对不起^ ^ ^）我也做了实验（虽然使用<代码> STD:：UnQuyjpTrasiPrime{No.BoOL（n+1）}；< /Cord>），然后用<代码>真< /COD>初始化。（最好一次初始化8个字节，这大概是
std:：vector
所做的）。但初始化不应占主要成本。无论如何，这也比
std:：vector
可能是msvc或Intel（icpc）慢
std:：vector
的实现较差？执行时间10.115秒这太可怕了。对于高达200的素数，一个好的算法需要大约4μs（任何现代CPU都需要一个），比原来短10倍多。用一个简单的算法，在3-4秒内可以计算出1000万个第一个素数，写为一个短练习。计算结果不需要时间，我只是在程序启动时没有立即输入结束数。
    for (int candidate = 3; candidate < n; ++candidate)
    {
        bool isPrime = true;
        for (int x = 2; x*x < candidate; x++)
        {
            if (candidate % x == 0)
            {
                isPrime = false;
                break;
            }
        }

        if (isPrime)
        {
            cout << candidate << "";
        }
    }

isPrime: initialize with all true
for(int i=2;i*i<=n;i++)
  for(int j =i*i;j<=n;j+=i)
    isPrime[j]=false;   // the if was not needed.

for (int x = 2; x < candidate; x++)//not before N prime numbers divine up to them
{
    if (candidate % x == 0)
        isPrime = false;
}

std::vector<int> primes(int n)
{
    std::vector<bool> is_prime(n+1,true);
    for(auto divisor=2; divisor*divisor <= n; ++divisor)
        for(auto candidate=divisor*divisor; candidate <= n; candidate+=divisor)
            is_prime[candidate]=false;
    std::vector<int> result;
    for(auto candidate=2; candidate <= n; ++candidate)
        if(is_prime[candidate]) result.push_back(candidate);
    return result;
}

std::vector<int> primes(int n)
{
    std::vector<bool> is_prime(n+1,true);
    for(auto divisor=2; divisor*divisor <= n; ++divisor)
        if(is_prime[divisor])
            for(auto candidate=divisor*divisor; candidate <= n; candidate+=divisor)
                is_prime[candidate]=false;
    std::vector<int> result;
    for(auto candidate=2; candidate <= n; ++candidate)
        if(is_prime[candidate]) result.push_back(candidate);
    return result;
}

std::vector<int> primes(int n)
{
    if(n<2) return {};
    if(n==2) return {2};
    std::vector<bool> is_prime((n+1)>>1,true);
    for(auto divisor=3; divisor*divisor <= n; divisor+=2)
        if(is_prime[divisor>>1])
            for(auto candidate=divisor*divisor; candidate <= n; candidate+=2*divisor)
                is_prime[candidate>>1]=false;
    std::vector<int> result(1,2);
    for(auto candidate=3; candidate <= n; candidate+=2)
        if(is_prime[candidate>>1]) result.push_back(candidate);
    return result;
}

#include <iostream>
#include <vector>


int main()
{
    //setup start parameters
    //test sequence
    std::vector<int> test_sequence {2};




    int end_number, start_number;
    start_number = 3;
    //take wished end number
    std::cin >> end_number;

    // test is wished number smaler than start number
    if (start_number < end_number)
    {
        // loop which goes trough every number between start and end number
        for (start_number; start_number <= end_number; start_number++)
        {
            bool isPrime = true;
            //test is this number prime
            for (int n = 0; n < test_sequence.size(); n++)
            {
                if (start_number % test_sequence[n] == 0 && start_number != test_sequence[n] )
                {
                isPrime = false;
                }
            }

            if (isPrime)
            {
                std::cout << start_number << std::endl;
                //hold result for next test
                test_sequence.push_back(start_number);
            }
        }

    }
    else
    {
    std::cout << "Wrong input";
    }

}