[C++] Fråga angående Template Class

Hej!

Har en fråga som inte riktigt besvarats av mina sökningar på Google som jag hoppas ni kan hjälpa mig med! Jag använder mig av en Template Class som ser ut ungefär såhär:

// template_class.h

template <class T> class TempClass {
private:
   ...
public:
   TempClass(int size) {
   ...
   }
};

Jag kan utan problem få objekt av denna Template Class under main på följande sätt:

// main.cpp
#include <template_class.h>

int main(int argc, char** argv) {
   ...
   TempClass<std::vector<int> > test(100);
   ...
}

Jag försöker nu att skapa ett objekt av min Template Class inuti en annan Class men det verkar inte fungera. Har testat att göra bl.a. på följande sätt:

// some_other_class.h
#include <template_class.h>

class SomeOtherClass {
private:
   TempClass<std::vector<int> > test(int k);
public:
   SomeOtherClass();
   ...
};

// some_other_class.cpp

SomeOtherClass::SomeOtherClass() {
   test(100);
}

Vid kompilering får jag följande felmeddelande:

undefined reference to `SomeOtherClass::test(int)'
collect2: error: ld returned 1 exit status

Vad gör jag för fel? Hur kan jag använda mig av ett objekt av en Template Class inuti en annan Class?

Tack för svar!

TempClass<std::vector<int> > test(int k);

Tar jag bort (int k) från funktionsdeklarationen och kompilerar därefter får jag istället följande felmeddelande:

error: no matching function for call to ‘SomeOtherClass::test(int)’
     test(100);

Kan det bero på att jag deklarerar försöker sätta size = 100 på följande sätt i .cpp filen?

// some_other_class.cpp

SomeOtherClass::SomeOtherClass() {
   test(100);
}

SomeOtherClass::SomeOtherClass() 
  : test(100)  // Initialisering av objektet test, anropar konstruktorn för TempClass.
{
   test(100);  // Ett anrop till funktionen test.
}

Det är ett objekt av klassen TempClass som jag försöker deklarera. Denna innehåller egna funktioner som jag sedan vill använda mig av inuti klassen SomeOtherClass. Jag kan fortfarande deklarera objekt från andra klasser som ser ut på följande sätt:

//some_third_class.h

class SomeThirdClass {
private:

public:
   SomeThirdClass() {
   }
};

på följande sätt inuti SomeOtherClass:

// some_other_class.h
#include <template_class.h>
#include <some_third_class.h>

class SomeOtherClass {
private:
   //TempClass<std::vector<int> > test(int k);
   SomeThirdClass stc;
public:
   SomeOtherClass();
   void someFunction();
   ...
};

Därefter går det bra att använda mig av SomeThirdClass' funktioner på följande sätt

...
stc.someFunction();
...

Går det att använda Template Class på liknande sätt? D.v.s. går det att deklarera en Template Class inuti en Class för att bl.a. använda dess funktioner inuti den senare klassen?

// some_other_class.h
class SomeOtherClass {
private:
    TempClass<std::vector<int>> test;
public:
    SomeOtherClass();
};

// some_other_class.cpp
SomeOtherClass::SomeOtherClass() :
    test(100)
{
}

Tack för svar! Jag antog att man skulle deklarera Template Class på samma sätt på en icke-Template Class men jag verkar ändå få problem vid deklarationen av denna. Deklarerar jag på följande sätt (d.v.s. precis som en vanlig, icke-Template Class) får jag följande felmeddelande vid kompilering (detta med [cmd]test(100);[cmd] bortkommenterat under SomeOtherClass.cpp):

TempClass<std::vector<int> > test;

error: no matching function for call to ‘TempClass<std::vector<int> >::TempClass()’
 SomeOtherClass::SomeOtherClass() {

Om jag istället kompilerar med TempClass<std::vector<int> > test(); och med detta med [cmd]test(100);[cmd] bortkommenterat under SomeOtherClass.cpp så kompilerar det utan problem. TempClass fungerar för övrigt under main precis som jag skrivit den ovan och programmet kör som det ska göra.

Kan problemet ligga iom att jag använder mig av C++98 istället för C++11 ?

Jag tror att jag börjar förstå problemet:

För att kunna deklarera ett objekt av en klass vid namn TempClass (och ha tillgång till dess funktioner) inuti en annan klass vid namn SomeOtherClass så måste TempClass ha en default constructor, d.v.s:

// template_class.h

template <class T> class TempClass {
private:
   ...
public:
   TempClass() { // take no parameters here!
   ...
   }
};

Stämmer detta?

Då hänger jag med! Har löst problemet genom att använda default construktor denna gång då det verkade vara det lättaste tillgångasättet för mitt problem.

Tack för hjälpen!

#include <iostream>

using namespace std;

class member
{
public:
    member()
    {
        cout << "member::member()" << endl;
    }

    ~member()
    {
        cout << "member::~member()" << endl;
    }
};

class foo
{
private:
    member a;
    member b;
    member c;

public:
    foo()
    {
        cout << "foo::foo()" << endl;
    }
    
    ~foo()
    {
        cout << "foo::~foo()" << endl;
    }

    foo(int n)
    {
        cout << "foo::foo(int n)" << endl;
    }

    foo& operator=(const foo& rhs)
    {
        cout << "foo& operator=(const foo& rhs)" << endl;

        return *this;
    }
};

class bar
{
private:
    foo f;

public:
    bar()
    {
        f = foo(123);
    }
    
    bar(bool) :
        f(123)
    {
    }
};

int main()
{
    bar a;
    cout << endl << " --- " << endl << endl;
    bar b (true);
    cout << endl << " --- " << endl << endl;
}

# Via automatisk initialisering + manuell tilldelning:

member::member()                # Initialisering av properties i foo:
member::member()                # ...
member::member()                # ...
foo::foo()                      # Automatiskt anrop till foo's default-konstruktor
                                #   (Orsakade ovanstående rader)
member::member()                # Intialisering av properties i foo:
member::member()                # ...
member::member()                # ...
foo::foo(int n)                 # Manuell initialisering av foo
                                #   (Orsakade ovanstående rader)
foo& operator=(const foo& rhs)  # Copy assignment till bar::f
foo::~foo()                     # ... innebär även att den överblivna foo städas upp
member::~member()               # ... tillsammans med allt sitt innehåll
member::~member()               # ...
member::~member()               # ...

# Via initialiseringslista:

member::member()                # Initialisering av properties i foo:
member::member()                # ...
member::member()                # ...
foo::foo(int n)                 # Direkt initialisering med rätt konstruktor

Nej det jag gjorde var att jag tog bort parametern size från konstruktorn samt alla variabler därifrån och skapade en funktion void setSize(int size) (som innehar allt som fanns inuti den tidigare konstruktorn) som jag istället kommer att använda mig av innan jag kan använda de andra funktionerna i TempClass. Detta har än så länge inte påverkat mitt program på något negativt sätt (har inte märkt av några buggar så länge som setSize körs innan någon av de andra funktionerna och det fungerar precis som tänkt). Initialiseringslista är nytt för mig, ska definitivt kika på detta!