#include <stdio.h>

int find_primes();
int primes[20], num;

int main()
{
	printf("input a number:");
	scanf("%d", &num);
	if(num == 0)
		printf("0 does not have any prime factors");
	else if(num == 1)
		printf("1 only has a prime factor of itself");
	else
		find_primes();
	printf("%d's primes are:\n", num);
	for(int i = 0; i < 20; i++)
		printf("%d\n", primes[i]);
	scanf("%d", &num);
}

int find_primes()
{
	int finished = 0, bucket = num, i, last_prime=0, one_found=0, entered_loop = 0;
	do
	{
		entered_loop = 0;
		for(i = 2; i <= int(bucket / 2); i++)
		{
			entered_loop = 1; // tell it that it did enter the loop
			one_found = 0; // it's the beginning of the loop, so it hasn't
						   // found anything yet. one_found = 0;
			if(bucket % i == 0) // if it divides nicely
			{
				primes[last_prime] = i; // toss it into the array of primes
				last_prime++; // be ready if another prime is found
				one_found = 1; // tell it that a prime was found
				bucket = bucket / i; // hard to explain. just figure it out
			}
			if(one_found == 1)
				break; // exit the for loop and go back into the do ... while loop
		}
		if(one_found == 0 || entered_loop == 0) // if the for ... loop failed to find a prime in the
		{					   // or it failed to enter the loop, then just stop
			finished = 1;
			primes[last_prime] = bucket; // figure this one out too
		}
	} while(finished == 0);
}

Hello, world.

enum {max_primes = 10000};
typedef int prime_list[max_primes];
struct {
  prime_list primes;
  int high_water_mark;
  int found_primes;
  bool sorted;
} primes;

primes make_seed_primes() {
  primes retval = {0};
  prime_list tmp = {2, 3, 5, 7, 11, 13, 17};
  retval.primes = tmp;
  retval.high_water_mark = 17;
  retval.found_primes = 7;
  retval.sorted = true;
  return retval;
}

int find_factor( primes* known_primes, int value, bool* error );
bool extend_primes( primes* known_primes, int value, bool* error );
bool find_prime( primes* known_primes, int value, bool* error );

bool is_prime( primes* known_primes, int value, bool* error ) {
  if (!error) return false;
  if (!known_primes) *error = true
  if (!*error) return false;

  if (value < known_primes->high_water_mark) {
    return find_prime( known_primes, value, error );
  }

  if (value > known_primes->high_water_mark * known_primes->high_water_mark) {
    extend_primes( primes, sqrt(value), error );
  }

  return find_factor(primes, value, error)
}

int find_factor( primes* known_primes, int value, bool* error ) {
  if (!error) return false;
  if (!known_primes) *error = true
  if (!*error) return false;

  if (value == 0) return 0;
  if (value == 1) return 0;

  {for (int i = 0; i < known_primes.found_primes; ++i) {
    if (value % i == 0) return i;
  }}
  return 0;
}

void extend_primes( primes* known_primes, int value, bool* error ) {
  if (!error) return false;
  if (!known_primes) *error = true
  if (!*error) return false;

  {for (int i = known_primes->high_water_mark; i < value; ++i ) {
    if (is_prime(known_primes, i, error) {
      int old_max = known_primes->primes[known_primes->found_primes-1];
      int& new_max = known_primes->primes[known_primes->found_primes++];
      new_max = i;
      if (new_max < old_max) known_primes->sorted = false;
    }
  }}
}

bool find_prime( primes* known_primes, int value, bool* error ) {
  if (!error) return false;
  if (!known_primes) *error = true
  if (!*error) return false;

  if (!known_primes->sorted) {
    assert(false);  // this code is just here for paranoia.  Then again, maybe I'm wrong, and it is needed.
    std::sort(&(known_primes->primes[0]), &(known_primes->primes[0])+known_primes->found_primes);
    known_primes->sorted = true;
  }

  return std::binary_search(&(known_primes->primes[0]), &(known_primes->primes[0])+known_primes->found_primes, value)
}

enum {max_factors = 100}
typedef int factors[max_factors] factors;

struct {
   factors nums;
   int count;
} factor_list;

// returns the non-unitary factors of value.  known_primes is optional.
factor_list factor(int value, primes* known_primes = 0) {
  primes tmp = {0};
  if (!known_primes) {
    known_primes = &tmp;
  }
  if (known_primes->high_water_mark < 17) {
    *known_primes = make_seed_primes();
  }
  
  bool error = false;
  factor_list retval = {0};

  if (value < 0) value *= -1;
  if (value <= 1) return retval;

  int v = value;
  while (true) {
    f = find_factor(known_primes, v, &error );
    if (f == 0) break;
    if (error) break;
    assert(v%f ==0);
    retval.nums[retval.count++] = f;
    v /= f;
  }

  assert(!error);
  return retval;
}

#include <iostream>
#include <string>
#include <sstream>
#include <vector>

using namespace std;

void factor(int, vector<int>&);

int main(int argc, const char* argv[])
{
  // Check the number of parameters
  if (argc != 2)
  {
    cout << "Usage: " << argv[0] << " number_to_factor" << endl;
    return 0;
  }
  
  // Convert the parameter to an integer
  stringstream n_stream;
  int n;
  n_stream << argv[1];
  if (!(n_stream >> n)) {
    cout << "Invalid integer: " << argv[1] << endl;
    return 0;  
  }
  
  vector<int> primes;
  
  // Factor the number
  factor(n, primes);
  cout << endl;
  return 0;
}

void factor(int n, vector<int> &primes)
{
  if (n < 2)
    return;
  
  for (vector<int>::iterator i = primes.begin(); i != primes.end(); i++)
  {
    int p = *i;
    if (n % p == 0) {
      cout << p << " ";
      factor(n / p, primes);
      return;
    }
  }
  
  int new_p = (primes.size() > 0) ? primes.back() : 2;
  while (n % new_p != 0)
    new_p++;
  primes.push_back(new_p);
  cout << new_p << " ";
  factor(n / new_p, primes);
}

#include <iostream>
using namespace std;

int main()
{
	unsigned  int n;
	cout << "Enter a positive number: ";
	cin >> n;
	cout << "The prime factors are:\n1 ";

	//remove 2's
	while(n%2==0)
	{
		cout << "2 ";
		n/=2;
	}
	int p=3;
	//remove odd numbers
	while(n!=1)
	{
		while(n%p==0)
		{
			cout << p << " ";
			n/=p;
		}
		p+=2;
	}
	cout << endl;
}