Crypt.hpp

#include <string>

namespace std
{
    class vector; //Vorwärtsdeklaration
}

namespace cr
{
    struct detailsCrypt;

    class Crypt
    {
        public:
        Crypt();
        std::string create_key() const;
        unsigned short transform_key(const std::string &key) const;
        unsigned short transform_key(const std::string &key, const std::vector<unsigned short> &random_numbers) const; //Hier gibts Probleme, aber es ist doch eine Referenz!?
        unsigned short downsize_key(unsigned short key) const;

        private:
        detailsCrypt *cd_data;
    };
}

Crypt.cpp

#include <string>
#include <vector> //Hier kommts doch schon
#include "crypt.hpp"
#include "random.hpp"
using namespace std;
using namespace rd;

namespace cr
{
    struct detailsCrypt
    {
        vector<unsigned short> rnd_numbers_key;
        vector<unsigned short> rnd_numbers_2byte;
        vector<unsigned short> rnd_numbers_4byte;
    };

    Crypt::Crypt()
    :cd_data(new detailsCrypt)
    {

    }

    string Crypt::create_key() const
    {
        string key;
        for(int i=0;i<6;++i)
        {
            char temp=randomize.rnd(97,122);
            key +=temp;
        }
        return key;
    }

    unsigned short Crypt::transform_key(const string &key) const
    {
        unsigned short amount=0;
        for(int i=0;i<6;++i)
        {
            cd_data->rnd_numbers_key.push_back(randomize.rnd(123,1000));
            amount +=cd_data->rnd_numbers_key.back() - key[i];
        }
        return amount;
    }

    unsigned short Crypt::transform_key(const string &key, const vector<unsigned short> &random_numbers) const
    {
        unsigned short amount=0;
        for(int i=0;i<6;++i)
        {
            amount +=random_numbers[i] - key[i];
        }
        return amount;
    }

    unsigned short downsize_key(unsigned short raw_key) const
    {
        if(raw_key < 12)
        {
            raw_key +=12;
        }

        if((raw_key % 12) == 0)
        {
            raw_key /=12;
        }
        else
        {
            raw_key = ((raw_key - (raw_key % 12)) / 12);
        }

        return raw_key;
    }
}

ERROR:
crypt.hpp:18: error: `std::vector' is not a template

Oder liegt der Fehler vll. wo anderst im Code?

MfG
Stromberg

btw: im namespace std:: darfst du IMO nur follständige spezialisierungen anlegen, alles andere - und somit au ch deine Forward-deklaration - ist IMO undefiniert

MfG
Stromberg

namespace std
{
    class vector<typename>; //Vorwärtsdeklaration
}

EDIT://
und selbst das wird nicht funktionieren da vektor als zweiten Template-Parameter noch den Allocator bekommt, der zwar ein Default-Argument hat, aber bei deiner Forward-Deklaration angegeben werden müsste - und dann kannst du IMO den const vector<>& nicht verwenden.

Lass es einfach sein und binde den Vektor ein wenn du ihn brauchst

btw: im namespace std:: darfst du IMO nur follständige spezialisierungen anlegen, alles andere - und somit au ch deine Forward-deklaration - ist IMO undefiniert

Genauer: jede Art Spezialisierung (explizit oder partiell) ist zulässig, sofern ein Nicht-Standard-Typ/Template in der Argumentliste auftaucht (die 2. Einschränkung deshalb, weil die Standardbibliothek ja bereits selbst für solche Typen bereits spezialisiert sein könnte).
Anders gesagt, jede Art Deklaration, die die Überladunsgauflösung beeinflußt (das wird sich in C++0x ändern) oder potentiell zu Mehrdeutigkeiten führt, ist in std unzulässig.

darthdespotism schrieb:

Lass es einfach sein und binde den Vektor ein wenn du ihn brauchst

Okay. Bin grad irgendwie auf nem Compilierzeit verküzungs Trip :D. Na ja, dann kann ich mir den cd_data Zeiger jetzt auch stecken.

MfG
Stromberg

allgemein würde ich std::sring und die container immer per header einbinden und nicht versuchen sie vorwärts zu deklarieren. Auch wenn im Standard steht, dass z.B. vector deklariert ist als vector<typename T, class Alloc = AllocatorT> > oder so ähnlich, ist es den Implementierern der Bibliotheken überlassen, zusätzliche Templateparameter (mit entsprechenden defaults) zu deklarieren, womit dann jede forward-Deklaration wieder zunichte gemacht wird.
für <iostream> gibts extra einen forward-header namens <iosfwd>, lediglich bei algorithmen, std::pair und anderen kleinen konstrukten kann man sich überlegen, ob man sie vorwärtsdeklariert. Allerdings wird man da meines Wissens nicht so unheimlich viel mit erkaufen, da es sich bei alledem hauptsächlich um templates handelt, die vom Compiler erst dann umgesetzt werden wenn solch ein template auch instantiiert wird.