#include <stdio.h>
#include <conio.h>
#include <iostream.h>

int Proverka(int num)
{
if (num/num != 1) 
if (num != num/1) 
return printf("%d\n Число простое\n",num);
else
return printf("\n Error");
}

int main()
 {
  clrscr();
   int My_num;
    cout << "Введите любое число от 1 до бесконечности \n";
    cout << "My_num= ";
    cin >> My_num;
  Proverka(My_num);
 return 0;
 }

D>int Proverka(int num)
D>{
D>if (num/num != 1) 
D>if (num != num/1) 
D>return printf("%d\n Число простое\n",num);
D>else
D>return printf("\n Error");
D>}

D>

if(false)

#include <stdio.h>
#include <conio.h>
#include <iostream.h>

// Есть ли смысл возвращать int (тем более не результат проверки, а
// результат вызова printf? К тому же, зачем printf когда ниже
// используется count/cin
// Предлагаю так:
bool is_prime(int value);

int Proverka(int num)
{
// Как уже сказали, цикла тут не видно. Самый простой вариант - цикл от 2 до num 
// и подсчет количества делителей. Небольшая оптимизация - цикл от 2 и до
// кадратного корня из num и опять же подсчет делителй.
if (num/num != 1) 
if (num != num/1) 
return printf("%d\n Число простое\n",num);
else
return printf("\n Error");
}

int main()
 {
  clrscr();
   int My_num;
    cout << "Введите любое число от 1 до бесконечности \n";
    cout << "My_num= ";
    cin >> My_num;
  Proverka(My_num);
 return 0;
 }

bool isPrimeNumber (int num)
{
    if (num < 0)
        num = -num;
    for (int i = 2; i < num / 2; i++)
        if (!(num % i))
            return 0;
    return 1;
}

int Proverka(int num)
{
if (num/num != 1) 
{
   if (num != num/1) 
   {
      return printf("%d\n Число простое\n",num);
   }
   else
   {
      return printf("\n Error");
   }
}

#include <iostream>
//(c) _Winnie
int P(int p,int i){return i--==p&&p-2&&P(i,i),i<2&&std::cout<<p<<' '||p%i&&P(p,i); }
int main() {  P(100,100); }

template<int>struct prime;//Вычисление N-го простого числа    prime<N>::result
template<int>struct is_prime;//Проверка числа на простоту     is_prime<N>::result

template<>struct prime<0>{enum{result=2};};//Число 2 нулевое простое число
template<>struct prime<1>{enum{result=3};};//Число 3 первое простое число
template<>struct prime<2>{enum{result=5};};//Число 5 второе простое число
template<>struct is_prime<0>{};//Число 0 не простое и не составное
template<>struct is_prime<1>{};//Число 1 не простое и не составное
template<>struct is_prime<2>{enum{result=true};};//Число 2 простое
template<>struct is_prime<3>{enum{result=true};};//Число 3 простое

template<int n>
struct is_prime{
  template<int k>
  struct helper{//Вспомогательная структура преобразующая цикл в рекурсию.
    enum{
      tmp=prime<k>::result,
      result=helper<(n<tmp*tmp)?0:(n%tmp?k+1:1)>::result
    };
  };
  template<>struct helper<0>{enum{result=true};};//Выход из цикла - число простое
  template<>struct helper<1>{enum{result=false};};//Выход из цикла - число составное
  enum{
    tmp=n%6,//Все простые числа большие трёх имеют вид 6*N+1 или 6*N+5
    result=helper<((tmp==1)||(tmp==5))+1>::result//Проверим делится ли n на 5 7 11 13 19 23...
  };
};

template<int n,bool>//Вспомогательная структура преобразующая цикл в рекурсию.
struct helper{enum{result=helper<n+2,is_prime<n+2>::result>::result};};
template<int n>
struct helper<n,true>{enum{result=n};};
template<int idx>//Возьмём N-1 простое число и будем прибалять двойку пока не получим новое простое число
struct prime{enum{result=helper<prime<idx-1>::result,false>::result};};


template<int i>
struct program:public program<i-1>{
  program():program<i-1>(){std::cout<<prime<i>::result<<endl;}
};
template<>
struct program<0>{
  program(){std::cout<<prime<0>::result<<endl;}
};

int main(){
  program<100>();
}