ich arbeite gerade ein C++-Tutorial durch und bin noch sehr weit am Anfang. Als Aufgabe soll hier ein Programm geschrieben werden, dass alle Primzahlen von 2 bis 100 aufzählt. Wenn ich das Programm bei mir starte, dann zählt das Programm allerdings alle Zahlen von 2 bis 100 auf und nicht nur die Primzahlen. Nachdem ich schon ewig den Fehler suche und kleine Änderungen vornehme, muss ich jetzt aufgeben, es sei denn jemand von euch kann mir helfen.

Falls Ihr mehr Infos braucht, sagt einfach Bescheid.

Danke schon mal im Voraus

#include <iostream>
#include <windows.h>

using namespace std;

bool istPrim(int Zahl);

int main()
{  
  bool Prim;
  int Zahl=2;

  while (Zahl<=100)
  {
        Prim=istPrim(Zahl);
        if(Prim=true)
          cout<<Zahl<<" ist eine Primzahl"<<endl;
        else
        ;
        Zahl=Zahl+1;
  };

  system("PAUSE");

  return 0;   
};

bool istPrim(int Zahl)
{
     bool Prim=true;

     for (int i=2;i<=Zahl-1;i=i+1)
     {
         if(Zahl%i==0)
          {
            Prim=false;
            break;
          }
     }  
  return Prim;  
};

if(Prim=true)

ist die Wurzel allen übels. Das muss Prim == true heißen.
Abgesehen davon: hast du den Code 1:1 vom Tutorial kopiert? Konstrukte wie ... <= Zahl -1 machen mir irgendwie Angst...

EDIT: Menno, wär ich nur 22 Sekunden schneller gewesen

Zeile 16: Du machst eine Zuweisung, keinen Vergleich (= statt ==)

gruß
syntax

[EDIT] Wenn der Lehrer nicht immer die Runde gehen würde, wär isch der schnellste gewesen.

gruß
syntax

cout << "2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97\n";

?

Und zur möglichen 1:1 Kopie. Nachdem mein vollkommen selbst geschriebenes progrämmchen nicht funktioniert hat, habe ich mich tatsächlich immer mehr dem vorgegeben Teil aus dem Tutorial angenähert (zumindest bei der Funktion unten).

PS: warum macht dir <=Zahl-1 Angst?

Vielen vielen dank an alle

PS: warum macht dir <=Zahl-1 Angst?

Vielen vielen dank an alle

Mir machts zwar keine Angst, aber ich finde <Zahl schöner und kürzer.

gruß
syntax

Abgesehen davon:

if(...)
    cout << "foo";
else
;

Das ist auch unschön. Das else dürfte zwar von jedem schlauen Compiler wegoptimiert werden, aber warum schreibst du das überhaupt hin um dann ne leere Anweisung draus zu machen?

EDIT:

Zahl=Zahl+1;

Auch unschön.

Apropos der Schnellste:

cout << "2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97\n";

?

Kann ich überbieten:

puts("2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97\n");

Kann ich überbieten:

Das würde ich mal messen (mein Rechner ist aber im Moment zu ausgelastet für Benchmarks). ostream::operator<< ist schließlich überladen für C-Strings, daher sollte das eigentlich das gleiche sein.

hustbaer schrieb:

Kann ich überbieten:

Das würde ich mal messen (mein Rechner ist aber im Moment zu ausgelastet für Benchmarks). ostream::operator<< ist schließlich überladen für C-Strings, daher sollte das eigentlich das gleiche sein.

Es ging glaub' ich nicht um die Geschwindigkeit sondern um die Anzahl der Zeichen...

Abgesehen davon muss die Aufgabe ja Berechnung aller Primzahlen von ... heißen.

SeppJ schrieb:

hustbaer schrieb:

Kann ich überbieten:

Das würde ich mal messen (mein Rechner ist aber im Moment zu ausgelastet für Benchmarks). ostream::operator<< ist schließlich überladen für C-Strings, daher sollte das eigentlich das gleiche sein.

Na gut, dann halt

static const char tfpnutoh[] = "2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97\n";
fwrite(tfpnutoh, 1, sizeof(tfpnutoh) - 1, stdout);

P.S.: In C++ natürlich cout.write(...). Den dadurch erzeugten Overhead beim Startup für die Konstruktion des cout-Objektes würde nicht nicht mitzählen.

Man könnte jetzt ne TMP Version basteln. Also komplett inklusive Konvertierung ins Dezimalsystem und Konkatenierung der Ergebnisse.

fwrite(black_template_magic_primes<100>::str, 1, black_template_magic_primes<100>::strlen, stdout);

Da sein Problem ja schon gelöst wurde, sollte das OK gehen. Behaupte ich mal. Wenn nicht einfach schreien.

Man könnte jetzt ne TMP Version basteln. Also komplett inklusive Konvertierung ins Dezimalsystem und Konkatenierung der Ergebnisse.

fwrite(black_template_magic_primes<100>::str, 1, black_template_magic_primes<100>::strlen, stdout);

Mein Unnötigkeitssensor schlägt wieder aus... oha, 6.9 - ich glaube gar, hustbaer sitzt da wirklich dran.

Und nein, ich sitze da nicht dran.

Obwohl es auch nicht notwendigerweise "unnötig" wäre, zumindest nicht subjektiv betrachtet. Kann man einiges dabei lernen, bzw. üben wenn es Dinge sind die man schon kann, aber vielleicht länger nicht mehr angewendet hat.

Hacker, überleg mal. Wie kann ein Sensor der - sich in deinem Besitz befindend - immer auf Anschlag steht noch weiter ausschlagen? Das kann nicht gehen.

Ich hab Alufolie rumgewickelt und bediene das ding durch eine Angel und einen Stock, aber der Zeiger zittert immer noch ein bisschen

Außerdem mach' ich eigentlich nie unnötige Sachen. Ich bin - in gewissen Zeiten - recht rational.

Man könnte jetzt ne TMP Version basteln. Also komplett inklusive Konvertierung ins Dezimalsystem und Konkatenierung der Ergebnisse.

Ei, das ist wirklich übel hart. Da bin ich mir selbst nach einigem Nachdenken nicht sicher, ob das überhaupt geht. Ich glaube man braucht aber mindestens variadic templates. Habe gerade keine Zeit, mir das genauer anzugucken.

sie sind einfach eine Vereinfachung für Typlisten, wie aus dem Alexandrescu bekannt.

Das ist Sepp sicherlich bekannt. Aber es sind generische Typlisten

Was soll denn bitte eine generische Typliste sein?

Was ich meine ist folgendes: Ich dachte, du meinst, man kann statt

template<typename ...c>
void func(//.....

Auch gleich das aufzurufende einsetzen.

template<char a, size_t s, char b>
void func(//...

In diesem Fall ist aber (ich weiß nicht ob das Wort hier passt) oberes generischer, nicht?

Ei, das ist wirklich übel hart. Da bin ich mir selbst nach einigem Nachdenken nicht sicher, ob das überhaupt geht.

Bitteschön.

#include <iostream>
#include <type_traits>

template <bool B>
struct bool_
	: std::integral_constant<bool, B>
{};

template <unsigned I>
struct unsigned_
	: std::integral_constant<unsigned, I>
{};

template <typename A, typename B>
struct dividable
	: bool_<A::value % B::value == 0>
{};

template <typename A, typename B>
struct or_
	: bool_<A::value || B::value>
{};

template <typename I>
struct increment
	: unsigned_<I::value + 1>
{};

template <typename A, typename B>
struct squared_less_equal
	: bool_<(A::value * A::value <= B::value)>
{};

template <typename A>
struct not_
	: bool_<!A::value>
{};

template
<
	template <typename, typename> class Func,
	typename Arg1
>
struct bind1st
{
	template <typename Arg2>
	struct binder1st : Func<Arg1, Arg2>
	{};
};

template
<
	template <typename, typename> class Func,
	typename Arg2
>
struct bind2nd
{
	template <typename Arg1>
	struct binder2nd : Func<Arg1, Arg2>
	{};
};

template
<
	typename Init,
	template <typename> class Cond,
	template <typename> class Next,
	template <typename> class Do,
	template <typename, typename> class Combine,
	typename Else
>
struct for_
	: std::conditional
	<
		Cond<Init>::value,
		typename std::conditional
		<
			Cond<Next<Init>>::value,
			Combine
			<
				Do<Init>,
				for_<Next<Init>, Cond, Next, Do, Combine, Else>
			>,
			Do<Init>
		>::type,
		Else
	>::type
{};

template <unsigned I>
struct is_prime
	: not_
	<
		for_
		<
			unsigned_<2>,
			bind2nd<squared_less_equal, unsigned_<I>>::template binder2nd,
			increment,
			bind1st<dividable, unsigned_<I>>::template binder1st,
			or_,
			bool_<true>
		>
	>
{};

template <>
struct is_prime<2>
	: bool_<true>
{};

template <>
struct is_prime<3>
	: bool_<true>
{};

template <char... S>
struct string : std::identity<string<S...>>
{
	static char const c_str[];
};

template <char... S>
char const string<S...>::c_str[] = { S..., 0 };

template <typename S1, typename S2>
struct append
	: append<typename S1::type, typename S2::type>
{};

template <char... S1, char... S2>
struct append<string<S1...>, string<S2...>>
	: string<S1..., S2...>
{};

template <unsigned I>
struct to_string
	: std::conditional
	<
		I < 10,
		string<I + '0'>,
		append<to_string<I / 10>, string<I % 10 + '0'>>
	>::type
{};

template <typename A, typename B>
struct less
	: bool_<(A::value < B::value)>
{};

template <typename I>
struct to_string_if_prime
	: std::conditional
	<
		is_prime<I::value>::value,
		append<to_string<I::value>, string<' '>>,
		string<>
	>
{};

template <unsigned N>
struct primes_below
	: for_
	<
		unsigned_<0>,
		bind2nd<less, unsigned_<N>>::template binder2nd,
		increment,
		to_string_if_prime,
		append,
		string<>
	>
{};

int main()
{
	std::cout << primes_below<100>::type::c_str << '\n';
}

http://ideone.com/tswvn

Man möge mir das überschüssige Whitespace am Ende verzeihen.

http://ideone.com/tswvnMan möge mir das überschüssige Whitespace am Ende verzeihen.

Sehr schöne Buchlösung, verliert aber Stilpunkte wegen for_

Jetzt noch bitte eine Variante, bei der die Tiefe der rekursiven Instantiierung beschränkt ist auf sagen wir 10.