Всё просто

#include <iostream>
 
 
#define N 150
 
int main(void)
{
    int m,i,j,k,q,P[N];
    
    std::cin >> m;
    
    if(m>=2) std::cout <<"2"<<std::endl;
    if(m>=3)  std::cout <<"3"<<std::endl;
 
    P[k=0]=3;
 
    for(i=5; i<=m; i+=2)
    {
        for (j=0; j<=k; j++)
        {
            q=P[j]; if(q*q>i) break;
            if(!(i)) goto NP; 
        }
        std::cout << i <<std::endl;
        if (k<N-1) P[++k]=i;
NP:;}       
}

#include <iostream>
 
bool isSimple(int a)
{
    for(int i=2; i<=a/2; ++i)
        if(a%i == 0)
            return false;
    return true;
}
 
int main()
{
     int m;
     std::cout<<"Enter m: ";
     std::cin>>m;
     int i=2;
     while(1)
     {
         if(issimple(i))
         {
            if(i > m)
               break;
            std::cout<<i<<'\n';
          }
     }
     return 0;
}

#include <iostream>
#include <list>
 
template <typename iterator>
bool is_prime (int number, const iterator & first_known_prime, const iterator & last_known_prime) {
    for (iterator current_prime = first_known_prime; current_prime != last_known_prime; ++current_prime) {
        if (number % *current_prime == 0) return false;
        else if (*current_prime * *current_prime > number) break;
    }
    
    return true;
}
 
template <typename output_container_type>
void get_primes (int supremum, output_container_type & empty_container) {
    output_container_type primes(1, 2);
    
    for (int i = 3; i < supremum; i += 2) if (is_prime(i, primes.begin(), primes.end())) primes.push_back(i);
            
    std::swap(primes, empty_container);
}
 
int main (int argc, char * const argv[]) {
    typedef std::list<int> container_type;
    container_type primes;
 
    int supremum;
    std::cin >> supremum;
    
    get_primes(supremum, primes);
    for (container_type::const_iterator i = primes.begin(); i != primes.end(); ++i) std::cout << *i << " ";
    
    return 0;
}

        if(isSimple(++i))

#include <iostream>
 
bool isSimple(int a)
{
    for(int i=2; i<=a/2; ++i)
        if(a%i == 0)
            return false;
    return true;
}
 
int main()
{
     int m;
     std::cout<<"Enter m: ";
     std::cin>>m;
     int i=2;
     while(1)
     {
         if(isSimple(i))
         {
            if(i > m)
               break;
            std::cout<<i<<'\n';
         }
         ++i;
     }
     return 0;
}

#include <iostream>
#include <vector>
 
int next_true (std::vector<bool> & sieve, int pos) {
    int i;
 
    for (i = pos; i < sieve.size(); ++i) if (sieve[i] == true) return i;
    
    return i;
}
 
void seed (std::vector<bool> & sieve) {
    for (int i = 2; i < sieve.size(); i = next_true(sieve, i + 1))
        for (int j = i * 2; j < sieve.size(); j += i) sieve[j] = false;
}
 
int main (int argc, char * const argv[]) {
    int supremum;
    std::cin >> supremum;
    
    std::vector<bool> sieve(supremum, true);
    sieve[0] = false;
    sieve[1] = false;
    
    seed(sieve);
    for (int i = 2; i < sieve.size(); ++i) if (sieve[i]) std::cout << i << ' ';
    
        return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
 
class Primes
{
public:
    Primes(int i=2)
    {
        if(isSimple(i))
            Vec.push_back(i);
    }
 
    void push_back(int i)
    {
        if(isSimple(i))
            Vec.push_back(i);
    }
 
    bool isSimple(int i)
    {
        for(int j=2; j<=i/2; ++j)
            if(i%j == 0)
                return false;
        return true;
    }
 
    int& operator [] (size_t i)
    {
        return Vec[i];
    }
 
    const int& operator [] (size_t i) const
    {
        return Vec[i];
    }
 
    const int size() const
    {
        return Vec.size();
    }
 
    std::vector<int>::iterator begin()
    {
        return Vec.begin();
    }
 
    std::vector<int>::iterator end()
    {
        return Vec.end();
    }
 
    std::vector<int>::const_iterator begin() const
    {
        return Vec.begin();
    }
 
    std::vector<int>::const_iterator end() const
    {
        return Vec.end();
    }
private:
    std::vector<int> Vec;
};
 
std::ostream& operator <<(std::ostream& os, const Primes& Ob)
{
    std::copy(Ob.begin(), Ob.end(), std::ostream_iterator<int>(os, "\n"));
    return os;
}
 
int main()
{
    int m=0;
    std::cout<<"Enter m: ";
    std::cin>>m;
    Primes Obj;
    int i=3;
    while(1)
    {
        if(i > m)
            break;
        Obj.push_back(i++);
    }
    std::cout<<Obj;
    system("pause");
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
 
int main()
{
    int m=0;
    std::cout<<"Enter m: ";
    std::cin>>m;
    int i=2;
    std::vector<int> Vec;
    try
    {
    std::generate_n(std::back_inserter(Vec), m, [&i, &m]() -> int
    {
        for(int j=2; j<=i/2; ++j)
        {
            if(i > m)
                throw 0;
            if(i%j == 0)
            {
                ++i;
                j=2;
            }
        }
        return i++;
    });
    }
    catch(...)
    {
    }
    std::vector<int>::iterator iter=std::find(Vec.begin(), Vec.end(), 0);
    if(iter != Vec.end())
    {
        std::cerr<<"Error\n";
        system("pause");
        return 1;
    }
    int t=std::distance(Vec.begin(), iter);
    Vec.resize(t);
    std::copy(Vec.begin(), Vec.end(), std::ostream_iterator<int>(std::cout, "\n"));
    system("pause");
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
 
bool isSimple(int a, const std::vector<int>& Vec)
{
    for(std::vector<int>::const_iterator Iter=Vec.begin();
        Iter!=Vec.end(); 
        ++Iter)
    {
        if(a % *Iter == 0)
            return false;
    }
    return true;
}
 
int main()
{
    int m=0;
    std::cout<<"Enter m: ";
    std::cin>>m;
    int i=2;
    std::vector<int> Vec;
    while(1)
    {
        if(i > m)
            break;
        if(isSimple(i, Vec))
            Vec.push_back(i);
        ++i;
    }
    std::copy(Vec.begin(), Vec.end(), std::ostream_iterator<int>(std::cout, "\n"));
    system("pause");
    return 0;
}