ich habe hier eine Klasse geschrieben welche mit grossen Zahlen arbeiten kann.
Nun habe ich mehrere Konstruktoren deklariert um die Basisdatentypen int unsigned long short char usw. in die neue Klasse BigNumber zu konvertieren.

Mein Problem ist jetzt folgendes:

schreibe ich sowas wie

unsigned char l = 255;

BigInteger num = l;

so wird mir statt des vordefinierten Konstruktors

BigInteger::BigInteger(unsigned char); der Konstruktor

BigInteger::BigInteger(int); aufgerufen kann mir das jemand mal erklären wieso?

Schreibe ich stattdessen explizit

BigInteger num = (unsigned char)l; so gehts. Wieso zur Hölle?

Für die initialisierung hatte ich mir überlegt eine parametrisierte Funktion zu schreiben die in etwa so arbeitet:

template<typename T>
inline void initialize(T t){
int countBlks =sizeof(T)/MAX_SIZE_OF_BLK;
cap = countBlks;
blk = new Blk[countBlks];
len = countBlks;
for (int i=0;i<countBlks;i++){
BlkType temp = t >> (i*MAX_SIZE_OF_BLK);
blk[i] = Blk(temp);
}

}

so nun ist sizeof(t) zur Laufzeitauswertung aber 0 und enthält nicht die Länge des Datentyps warum?

^^^^

Hat sich erledigt, habe den = Operator überschrieben und der kann nur ints

Aber was noch wichtig wäre hervorzuheben ist, daß

BigInteger num = l;

eigentlich erst einmal den Default cto aufruft und dann den assignment operator (=) ausführt. Sprich der Code, den der Compiler generiert, sieht eigentlich so aus:

BigInteger num()
num = l;

Sprich der Code, den der Compiler generiert, sieht eigentlich so aus:

BigInteger num()
num = l;

Nein, das hat nichts mit Zuweisungsoperator zu tun, das ruft sehrwohl wunderbar den normalen Konstruktor auf. Ein kleines Testprogramm zeigt dir so etwas sofort:

#include <iostream>
using namespace std;

struct Test
{
    Test()
    {
        cout << "Default Constructor" << endl;
    }

    Test( int num )
    {
        cout << "Construct with num = " << num << endl;
    }

    Test(const Test& other)
    {
        cout << "Copy Constructor Constructor" << endl;
    }

    Test& operator=(const Test& other)
    {
        cout << "Operator =" << endl;
    }
};

int main()
{
    cout << "-----" << endl;
    Test me = 1;
    cout << "-----" << endl;
    Test org;
    Test t;
    t = org;
}

Ausgabe:

-----
Construct with num = 1
-----
Default Constructor
Default Constructor
Operator =

zwischen den "-----" siehst du keine Default Constructor, Copy Constructor oder sonstwas, nur die eine Zeile!

Aber was noch wichtig wäre hervorzuheben ist, daß

BigInteger num = l;

eigentlich erst einmal den Default cto aufruft und dann den assignment operator (=) ausführt. Sprich der Code, den der Compiler generiert, sieht eigentlich so aus:

BigInteger num()
num = l;

Nein. Das stimmt nicht! Das hast Du Dir entweder selbst (falsch) zusammengereimt, oder falsch übernommen. Die erste Zeile stellt eine "Kopier-Initialisierung" dar. Das hat nichts mit Default-Konstruktoren oder Assignment-Operatoren zu tun!

Außerdem ist BigInteger num(); eine Funktionsdeklaration!

Aber folgender Code ist doch dann recht inneffektiv, oder?

BigInteger num; // deklaration von num und ausführung des default-ctor
num = l; // assignment operator

Kopierinitialisierung - kann ich darunter den copy-ctor verstehen?

http://www.gotw.ca/gotw/036.htm

Carstig schrieb:

Aber folgender Code ist doch dann recht inneffektiv, oder?

BigInteger num; // deklaration von num und ausführung des default-ctor
num = l; // assignment operator

kommt auf die Implementierung von BigInteger an.