Grundsatzfrage bzgl. der Eignung für die Programmierung

_matze

berniebutt schrieb:

double DobiFunction()
{
   double ergebnis, schwachsinn = 100.00;
   ergebnis = pow(schwachsinn, 3); 
   result ergebnis;
}

daddeldu! :p

Auch Spaß-Code sollte kompilierbar sein!

Sone

_matze schrieb:

Auch Spaß-Code sollte kompilierbar sein!

Und effizient.
Ich wette meinen Linken Daumen, schwachsinn * schwachsinn * schwachsinn ist schneller als die Schleife in pow (ganz zu schweigen von std::pow ).

_matze

Sone schrieb:

Und effizient.
Ich wette meinen Linken Daumen, schwachsinn * schwachsinn * schwachsinn ist schneller als die Schleife in pow (ganz zu schweigen von std::pow ).

Ich würde jetzt gerne meinen rechten Ringfinger dagegen wetten, aber vermutlich hast du Recht.

Sone

_matze schrieb:

Sone schrieb:

Und effizient.
Ich wette meinen Linken Daumen, schwachsinn * schwachsinn * schwachsinn ist schneller als die Schleife in pow (ganz zu schweigen von std::pow ).

Ich würde jetzt gerne meinen rechten Ringfinger dagegen wetten, aber vermutlich hast du Recht.

#include <iostream>
#include <ctime>
#include <cmath>

int main()
{
    int prime = 7;
    clock_t secs = clock();

    for(unsigned ct = 0;ct < 1e8;++ct)
        volatile int tmp = prime * prime * prime;

    std::cout << clock() - secs << '\n';
    secs = clock();

    for(unsigned ct = 0;ct < 1e8;++ct)
        volatile int tmp = pow(prime, 3);

    std::cout << clock() - secs << '\n';
}

Bei mir ist das im Durchschnitt einige Millisekunden langsamer, bei Ideone anscheinend nicht!
Und ein paar mal war pow schneller!
Wie ist das möglich!?
Ideone

Swordfish

ideone für Performancemessungen in Sekunden - ja ne, is klar.

#include <cmath>
#include <chrono>
#include <random>
#include <iostream>

#include <windows.h>

int main()
{
	std::mt19937 mt;
	mt.seed( static_cast< long unsigned >( std::chrono::system_clock().now().time_since_epoch().count() ) );

	double x = 0.;
	double volatile y = 0.;

	LARGE_INTEGER t1 = {};
	LARGE_INTEGER t2 = {};

	QueryPerformanceCounter( &t1 );

	for( unsigned ct = 0; ct < 1e8; ++ct ) {

		x = static_cast< double >( mt() ) / mt();
		y = x * x * x;
	}

	QueryPerformanceCounter( &t2 );
	std::cout << "***: " << ( t2.QuadPart - t1.QuadPart ) << '\n';

	QueryPerformanceCounter( &t1 );

    for( unsigned ct = 0; ct < 1e8; ++ct ) {

		x = static_cast< double >( mt() ) / mt();
		y = pow( x, 3. );
	}

	QueryPerformanceCounter( &t2 );
	std::cout << "pow: " << ( t2.QuadPart - t1.QuadPart ) << '\n';
}

***: 5373502
pow: 22601891

redrew99

glühnase schrieb:

redrew99 schrieb:

Ja, wobei es für Anfänger vielleicht besser ist, wenn Strings eher als Klasse wahrgenommen werden und nicht als eigener Datentyp.

Ah, und Klassen sind keine Datentypen?

Ne, für Anfänger ist es besser, wenn sie die Begriffe richtig lernen.

<:xmas2:>

Ich würde eine Klasse als Anfänger eher als Datenstruktur denn als Datentyp sehen.

redrew99

kk-in-hh schrieb:

Wie meinst du das und was wäre schlecht daran?
Auf was beziehst du dich da? String-Literale?
Ja und? Es ist doch völlig egal, ob std::string ein eingebauter oder ein benutzerdefinierter Typ ist.

Viele Anfänger (bin ja selber einer), denken, wenn sie das erste Mal mit Strings zu tun haben, damit genau das gleiche machen können wie z.B. mit einem Char, Int, etc.

Daß string aber eine Klasse ist, weiß man als Anfänger oftmals nicht. Und demzufolge natürlich auch nicht, warum man z.B. strings addieren kann.

Weil dem TE dieses Hintergrundwissen fehlt, funktioniert auch sein Programm nicht.