#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;

bool is_prime(long double a) {
	for(long double d = 2; d < floor(a/2 + 1); ++d)
		if(!fmod(a, d))
			return false;
	return true;
}

template <class Large>
class primes_generator {
	Large cp;
public:
	primes_generator()
		:cp(2) {}
	Large operator() () {
		Large tp = cp;
		while(!is_prime(tp))
			++tp;
		cp = tp + 1;
		return tp;
	}
};

template <class ExtraLarge, class Large>
ExtraLarge mnu(Large n) {
	ExtraLarge t = 2;
	for(Large i = 1; i < n; ++i)
		t *= 2;
	return t - 1;
}

int main(int, char**) {
	vector<unsigned> primes(4423);
	generate(primes.begin(), primes.end(), primes_generator<unsigned>());
	vector<long double> mn;
	transform(primes.begin(), primes.end(), back_inserter(mn), mnu<long double, unsigned>);
	vector<long double> mp;
	remove_copy_if(mn.begin(), mn.end(), back_inserter(mp), is_prime);
	cout << "Mersenne primes: " << endl;
	copy(mp.begin(), mp.end(), ostream_iterator<long double>(cout, "\n"));
	getchar();
	return 0;
}

1. geh bem primes_generator ab der 3 in 2er Schritten. Die geraden Zahlen kannst du eh alle überspringen.
2. bei is_prime ebenfalls erst durch 2 testen, und dann ab 3 in 2er Schritten um die geraden Zahlen zu überspringen.
3. geh bei is_prime nur bis d*d<a+1.
4. ich kann mir vorstellen, dass double eventuell zu Problemen führen könnte, bin mir aber nicht sicher (ich kenne fmod nicht)
5. anstelle von

vector<unsigned> primes(4423);

würde ich

vector<unsigned> primes;
primes.reserve(4423);

nehmen. Sollte auch eine Kleinigkeit bringen, da bei reserve keine default construktoren aufgerufen werden (obs bei build-in types was bringt weisz ich aber nicht)
6. deine Funtion mnu rechnet doch im Grunde die n+1te Potenz von 2, oder? Dafür gibt es auch eine std Funktion, nämlich pow(2,n+1). Bei der Übergabe musst du da natürlich bind_first benutzen.
Wenn du es trotzdem selbst schreiben willst (ungetestet):

template <class ExtraLarge, class Large>
ExtraLarge mnu(Large n) {
    ExtraLarge t=2;
    while(n>0){
        if(n%2==0){
            t*=t;
            n/=2;
        }
        else{
            t*=2;
            --n;
        }
    }
    return t;
}

EDIT: ich hab was vergessen: du speicherst ja eh alle Primzahlen ab! Da reicht es dann, wenn du immer durch alle vorher gefunden Primzahlen zu dividieren versuchst, die kleiner sind als die Wurzel aus der aktuellen Zahl.

Ich würde zu einer eigenen Klasse raten.

Hier der Code:

prim.h

#ifndef PRIMZAHLEN_H
#define PRIMZAHLEN_H

#include <deque>

class Prim{
	std::deque<unsigned long> prims;
	bool isprim(unsigned long cand);
public:
	Prim(){prims.push_back(2);prims.push_back(3);}
	unsigned long calcprim(size_t n);
	const std::deque<unsigned long>& getallprim(){return prims;}
};

#endif //PRIMZAHLEN_H

prim.cpp

#include "prim.h"
#include <deque>
#include <assert.h>

using namespace std;

bool Prim::isprim(unsigned long cand){
	for(size_t i=0;prims[i]*prims[i]<=cand;++i)
		if(cand%prims[i]==0)
			return false;
	return true;
}

unsigned long Prim::calcprim(size_t n){
	assert(n>0);
	if(n>prims.size())
		for(size_t i=prims.size();i<n;++i){
			unsigned long cand;
			for(cand=prims[prims.size()-1]+2;!isprim(cand);cand+=2);
			prims.push_back(cand);
		}
	return prims[n-1];
}

main.cpp

#include "prim.h"
#include <fstream>
#include <deque>
#include <algorithm>

using namespace std;

long double mnu(unsigned long n){
	long double t=2;
	while(n>0){
        if(n%2==0){
            t*=t;
            n/=2;
        }
        else{
            t*=2;
            --n;
        }
	}
    return t-1;
}

int main(){
	Prim prim;
	prim.calcprim(4432);
	deque<long double> mers;
	transform(prim.getallprim().begin(),prim.getallprim().end(),back_inserter(mers),mnu);
	ofstream out("mersenne.txt");
	copy(mers.begin(),mers.end(),ostream_iterator<long double>(out,"\n"));
	return 0;
}

Entschuldige bitte, dass ich das hier einfach so als Eigenzweckübung missbrauche.
Habe ich noch Fehler in meinem Programm? Wenn ja bitte sagen.
Und was war nochmal der Header für size_t? Ich glaube ich habe den jetzt inkludiert weil er wohl in deque inkludiert ist, sollte ihn aber wohl besser selbst nochmal inkludieren.

So einfach kann es nicht sein. Dein Vorschlag sieht leider viel komplizierter und deshalb hab ich Angst ihn auszuprobieren

Hier die neue Code:

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;

bool is_prime(long double a) {
	if(a <= 3)
		return true;
	for(long double d = 5; d*d < a + 1; d += 2)
		if(!fmod(a, d))
			return false;
	return true;
}

template <class Large>
class primes_generator {
	Large cp;
public:
	primes_generator()
		:cp(2) {}
	Large operator() () {
		Large tp = cp;
		while(!is_prime(tp))
			++tp;
		cp = tp + 1;
		return tp;
	}
};

template <class ExtraLarge, class Large>
ExtraLarge mnu(Large n) {
	ExtraLarge t = 2;
	for(Large i = 1; i < n; ++i)
		t *= 2;
	return t - 1;
}

int main(int, char**) {
	cout << "reserving space for prime numbers...";
	vector<long unsigned> primes(4423);
	cout << " ok" << endl << "calculating prime numbers...";
	generate(primes.begin(), primes.end(), primes_generator<long unsigned>());
	vector<long double> mn;
	cout << " ok" << endl << "generating Mersenne numbers...";
	transform(primes.begin(), primes.end(), back_inserter(mn), mnu<long double, long unsigned>);
	cout << " ok" << endl << "determing the Mersenne primes...";
	vector<long double> mp;
	remove_copy_if(mn.begin(), mn.end(), back_inserter(mp), is_prime);
	cout << "Mersenne primes: " << endl;
	copy(mp.begin(), mp.end(), ostream_iterator<long double>(cout, "\n"));
	getchar();
	return 0;
}

P.S. Im Wiki steht, dass die 20 MP aus 1,332 Ziffern besteht. Kann "long double" so was behandeln?

Was ich ausgebe sind tatsächlich die Mersenne Numbers. Ich habe ja geschrieben warum ich die nicht umgerechnet habe: ab der 69. Zahl von den 4000 und etwas sind sie schon #INF. Ich denke da liegt dann eben auch das Problem beim remove_copy_if() am Ende: is_prime läuft so ewig lange bei all den Zahlen weil alle Zahlen #INF sind.

Meine Berechnung sollte aber definitiv schneller sein. Ich erhalte die ersten 1 Million Primzahlen in 19 Sekunden. Es geht natürich noch viel schneller wenn sich die guten Programmierer hier mal ans Werk setzen, aber für mich reicht das mal.

template <class Large>
class primes_generator {
    Large cp;
public:
    primes_generator()
        :cp(3) {}
    Large operator() () {
        Large tp = cp;
        while(!is_prime(tp))
            tp+=2;
        cp = tp + 2;
        return tp;
    }
};

So, das Einzige wo du jetzt extra machen musst ist 2 am Anfang per Hand hinzuzufügen, bevor der generator los läuft. Braucht schonmal wieder nur halb so lang.

Auszerdem sollte dein is_prime() lieber einmal durch 2 testen und dann ab 3 in 2er schritten. Ansonsten gibts probleme bei 2er potenzen nachher.

cout << " ok" << endl << "generating Mersenne numbers...";
	transform(primes.begin(), primes.end(), back_inserter(mn), mnu<long double, long unsigned>);
	cout << " ok" << endl << "determing the Mersenne primes..." << endl;
	remove_copy_if(mn.begin(), mn.end(), ostream_iterator<long double>(cout, "\n"), not1(ptr_fun(is_prime)));
	cout << "done.";

Das Problem war, dass "remove_copy_if" die Funktion negiert. Jetzt sollte es funkzionieren...
Nach etwa 20 Minuten sind die ersten 15 MP da!