Wat betekent “ontbrekend sjabloonargument”?

Ik ben vrij nieuw in C++ en deze site, dus er zullen zeker fouten zijn. Wanneer ik mijn code probeer te compileren, krijg ik fouten zoals error: missing template argument before 'b'. Ik ben al uren op zoek over de wereld naar antwoorden en het heeft me hier gebracht.

Mijn opdracht is om een getemperde class Collection te implementeren waarin een verzameling van
Objecten die een array gebruiken, langs
met de huidige grootte van de collectie.

   #include <iostream>
    #include "collection.h"
    using namespace std; v
    int main(int argc, char* argv[])
    {
       collection b;  //<----error missing template argument before 'b'
        return 0;
    }

   #ifndef COLLECTION_H
    #define COLLECTION_H
    #include <iostream>
    template <typename obj>
    class collection
    {
    public:
        collection();
        bool isEmpty() const;
        void makeEmpty();
        void insert(obj val);
        void remove(obj val);
        bool contains(obj val) const;
    private:
        size_t size;
        obj* col[];
    };
    #endif

   #include "collection.h"
    template <typename obj>
    collection<obj>::collection() :size(10)
    {
        col = new obj*[size];
    }
    template <typename obj>
    bool collection<obj>::isEmpty() const
    {
        for(size_t k = 0; k < size; k++)
        {
            if(col[k] != NULL)
                return false;
        }
        return true;
    }
    template <typename obj>
    void collection<obj>::makeEmpty()
    {
        for(size_t k = 0; k < size; k++)
        {
            col[k] = NULL;
        }
    }
    template <typename obj>
    void collection<obj>::insert(obj val)
    {
        int temp = 0;
        for(size_t s = 0; s < size; s++)
        {
            if(col[s] != NULL)
                temp++;
        }
        if(temp >= size)
        {
            obj* temp = new obj*[size*2];
            for(size_t c = 0; c < size; c++)
                temp[c] = col[c];
            delete col;
            col = temp;
        }
        else
            col[temp] = val; 
    }
    template <typename obj>
    void collection<obj>::remove(obj val)
    {
        for(size_t x = 0; x < size; x++)
        {
            if (col[x] == val)
            {
                for(size_t y = x; y < size-1; y++)
                {
                    col[y] = col[y+1];
                }
                col[size-1] = NULL;
                return;
            }
        }
    }
    template <typename obj>
    bool collection<obj>::contains(obj val) const
    {
        for(size_t z = 0; z < size; z++)
        {
            if(col[z] == val)
                return true;
        }
        return false;
    }

Antwoord 1, Autoriteit 100%

u moet zeggen wat het is van een verzameling.

template <class A> class collection {}

vereist dat u het gebruikt als

collection<int> b;

of een bepaald type. Dat maakt dan een verzameling intwoorden. Je hebt het niet verteld wat je wilt een verzameling.


Antwoord 2, Autoriteit 30%

Eerste: sjabloon op type instantiëren. Dus als u een template <typename obj> class T {...};je zou het moeten gebruiken als

void main { 
  T<int> t; 
  T<bool> t1; // .. etc
}

U kunt een sjabloon gebruiken met een standaardwaarde voor de parameter typename die is gedefinieerd in de declaratie van de klassensjabloon

template <typename obj = int> class T {/*...*/};
void main { 
  T<> t;
} 

maar hoe dan ook, je moet lege punthaken plaatsen als je het zonder parameter gebruikt.

Tweede: plaats tijdens het declareren de sjabloon in zijn geheel in het headerbestand. Elke definitie van zijn methoden zou in het bestand “*.h” moeten staan, vraag me niet waarom, maar splits het niet op in de header en het “cpp”-bestand.

Hopelijk helpt het.


Antwoord 3, autoriteit 15%

Nou, je mist een sjabloonargument. U kunt geen collection-object maken, dat is slechts een sjabloon.

U kunt alleen b.v. een collection<int>of collection<std::string>.


Antwoord 4, autoriteit 5%

Je moet het type voor de sjabloon specificeren, zoals intof een ander type:

collection<int> b; 

Antwoord 5

Er zitten een groot aantal fouten in uw code. Definieer eerst uw sjabloon in een headerbestand:

Plaats in collection.h het volgende:

#ifndef COLLECTION_H
#define COLLECTION_H
    template <typename obj>
    class collection
    {
    public:
      collection() {}
        bool isEmpty() const;
        void makeEmpty();
        void insert(obj val);
        void remove(obj val);
        bool contains(obj val) const;
    private:
        size_t size;
        obj* col[];
    };
#endif

Doe dan in een .cpp-bestand in een hoofdfunctie het volgende:

 collection<int> b;

In plaats van int kunt u een ander type gebruiken, maar het belangrijkste punt is dat U EEN TYPE NODIG HEBT om een sjabloon te instantiëren.

Other episodes