Hey all, I wrote a C++ object that gets the prime factors of any number and thought I would share it.

The comments should help you and the variables have very clear names, so it should be self-documenting.

PrimeFactorsOfCalculator.h

#pragma once

#include <vector>

using namespace std;

class PrimeFactorsOfCalculator
{
public:
	PrimeFactorsOfCalculator(void);
	~PrimeFactorsOfCalculator(void);

	long GetNumber();
	void SetNumber(long inNumber);
	vector<int> GetPrimeFactors(bool inAllowDuplicates = false, bool inForceRecalculate = false);


private:
	long Number;
	vector<int> PrimeFactors;
	bool IsPrime(long inNumber);

	long MultiplyPrimes();

};

PrimeFactorsOfCalculator.cpp

#include "PrimeFactorsOfCalculator.h"
#include <math.h>
#include <algorithm>

using namespace std;

PrimeFactorsOfCalculator::PrimeFactorsOfCalculator(void)
{
}


PrimeFactorsOfCalculator::~PrimeFactorsOfCalculator(void)
{
}

long PrimeFactorsOfCalculator::GetNumber()
{
	return Number;
}

void PrimeFactorsOfCalculator::SetNumber(long inNumber)
{
	Number = inNumber;
	PrimeFactors.clear();
}

//
// Gets the prime factors of Number. 100 return 2,5.
//	
// inAllowDuplicates - Allow duplicates, for example, 100 has prime 
// factors of 2 and 5,but in order to get 100, you need 2*2*5*5. So 
// instead of returning 2,5 the return array will be 2,2,5,5.
//
// inForceRecalculate - By default the values are stored at first
// calculation and only recalcuated when needed. this is for efficiency.
vector<int> PrimeFactorsOfCalculator::GetPrimeFactors(bool inAllowDuplicates, bool inForceRecalculate)
{
	// Don't recalculate if already calculated.
	if (PrimeFactors.size() > 0 && !inForceRecalculate)
		return PrimeFactors;

	PrimeFactors.clear();
	// Calculate
	if (Number % 2 == 0 && Number >= 2)
	{
		PrimeFactors.push_back(2);
	} 

	for (int i = 3; i < Number/3; i++)
	{
		if (Number % i == 0 && IsPrime(i))
			PrimeFactors.push_back(i);
	}

	// Allow duplicates, for example, 100 has prime factors of 2 and 5,
	// but in order to get 100, you need 2*2*5*5. So instead of returning
	// 2,5 the return array will be 2,2,5,5.
	if (inAllowDuplicates)
	{
		while (MultiplyPrimes() != Number)
		{
			long multipliedVal = MultiplyPrimes();
			long val = 0;

			if (multipliedVal != 0)
				val = Number / multipliedVal;

			if (IsPrime(val))
			{
				PrimeFactors.push_back(val);
				continue;
			}
			else
			{
				// recursion
				PrimeFactorsOfCalculator calc = PrimeFactorsOfCalculator();
				calc.SetNumber(val);
				vector<int> duplicateFactors = calc.GetPrimeFactors();
				for (size_t i = 0; i < duplicateFactors.size(); i++)
				{
					PrimeFactors.push_back(duplicateFactors.at(i));
				}
			}
		}
	}

	sort(PrimeFactors.begin(), PrimeFactors.end());
	return PrimeFactors;
}

bool PrimeFactorsOfCalculator::IsPrime(long inNumber)
{
	// Get square root as that is the highest possible factor
	// and add one in case precision is screwy.
	long highestPossibleFactor = (long)(sqrt((double)inNumber) + 1);

	// Handle 2 separatly then no other even has to be checked
	if (inNumber % 2 == 0) 
		return false;

	// See if the value is divisible by any odd number
	// if so it is not prime
	for (int i = 3; i < highestPossibleFactor; i+=2)
	{
		if (inNumber % i == 0) 
			return false;
	}
	return true;
}

long PrimeFactorsOfCalculator::MultiplyPrimes()
{
	if (PrimeFactors.size() == 1)
		return PrimeFactors.at(0);
	else if (PrimeFactors.size() > 1)
	{
		int minVal = PrimeFactors.at(0);
		for (size_t i = 1; i < PrimeFactors.size(); i++)
		{
			minVal *= PrimeFactors.at(i);
		}
		return minVal;
	}
	else return 1; // 1 is always a prime
}

And last here is a sample main function that uses this.

Main.cpp

#include <vector>
#include "PrimeFactorsOfCalculator.h"

using namespace std;

int main()
{
	PrimeFactorsOfCalculator calc = PrimeFactorsOfCalculator();
	calc.SetNumber(100);
	vector<int> primeFactors = calc.GetPrimeFactors();
	vector<int> primeFactorsWithDuplicates = calc.GetPrimeFactors(true, true);


	calc.SetNumber(200);
	primeFactors = calc.GetPrimeFactors();
	primeFactorsWithDuplicates = calc.GetPrimeFactors(true, true);


	calc.SetNumber(1000);
	primeFactors = calc.GetPrimeFactors();
	primeFactorsWithDuplicates = calc.GetPrimeFactors(true, true);

	calc.SetNumber(14593);
	primeFactors = calc.GetPrimeFactors();
	primeFactorsWithDuplicates = calc.GetPrimeFactors(true, true);

	calc.SetNumber(12345678);
	primeFactors = calc.GetPrimeFactors();
	primeFactorsWithDuplicates = calc.GetPrimeFactors(true, true);
}