nie wiem za bardzo jak to powiedzieć... mam szablon klasy i chcę go przerobić żeby działał tak samo ale był jednocześnie tablicą zmiennych podanych przy deklaracji...
0
0
template<typename typ>class kontener
{
private:
typ jakiescos;
jakieś zmienne
public:
jakieś funkcje i konstruktory
};
teraz chcę żeby jak zrobię
kontener<int> kontener;
kontener=5;
a=kontener;
to a było równe 5 i kontener.jakiescos miało 5... czyli po prostu chcę, żeby klasa funkcjonowała jako zmienna podanego typu i miała moje funkcje(tak ogólnie to to ma działać jak tablica podanego typu ale to się zrobi potem)
0
Przeciąż odpowiednie operatory. Ew. podziedzicz z jakiegoś STLowego kontenera, ale miej na uwadze, że nie mają one wirtualnego destruktora.
0
Może podaj przykład użycia, bo w tej chwili wygląda jak próba przyszycia piątej łapy do pleców psa. To co podałeś sugeruje raczej 2 funkcje setXXX() i getXXX() a nie jakieś udziwnione przeciążone operatory przypisania czy konwersji. Coś jakby vector::size() i vector::resize().
1
template<typename typ>class kontener
{
private:
typ jakiescos;
jakieś zmienne
public:
jakieś funkcje i konstruktory
kontener<typ> & operator=(const typ& x) {
………
jakiescos = x;
………
return *this;
}
};
0
Na lekcji informatyki sprawdzałem temat operatorów i trochę ogarniam... ale jak teraz zrobić z mojej klasy tablicę zmiennych type a nie jednej zmiennej type?
1
przeladuj operator [] tak by sie dostawal do wektora w sensie
obiekt[index] bedzie znaczyl
(to jest pseudokod. Nie bedzie sie kompilowac pokazuje jedynie idee)
operator[] (int index)
{
return kontener[index];
}
1
#include <iostream>
#include <vector>
template<typename T>
struct Container : public T
{
using T::T;
};
int main()
{
Container<std::vector<int>> c { 1, 2, 3, 4 };
std::cout << c[3];
return 0;
}
http://melpon.org/wandbox/permlink/zn579hII8jo4KgAU
wyjdź od tego i baw się resztą
0
po paru próbach doszedłem do tego:
namespace niktech
{
template<typename type>class vector
{
private:
int cellcount;
public:
type *container;
vector()
{
cellcount=1;
container=NULL;
}
vector(int celcount)
{
cellcount=celcount;
container=new type[cellcount];
}
int size()
{
if (sizeof(container)>0)
{
return sizeof(container)/sizeof(container[0]);
}
else
{
return 0;
}
}
type & operator[] (const int index)
{
return container[index];
}
};
};
ale jak zrobię:
vector wektor;
int i=0;
wektor[0]=i;
program się kompiluje i wywala błąd jakiś...
0
bo przepisujesz cos do nulla. ustawiles w konstruktorze swoj pointer na NULL przeciez...
0
więc to błąd funkcji size()...
0
no to z tego co widzę został jeden problem... jak sprawdzić rozmiar dynamicznej tablicy? bo mam z tym problemy
0
Nijak, jeżeli to nie jest vector to nie możesz - musisz mieć gdzieś ręcznie zapisany (w zmiennej) i automatycznie inkrementować/dekrementować.
0
to teraz mam błąd którego nie rozumiem...
template<typename type>class vector
{
private:
type *container;
public:
void add( vector <type> Vector )
{
if (container!=NULL)
{
type *newcontainer=new type[cellcount+Vector.size()];
for (int i=0; i<cellcount; i++)
{
newcontainer[i]=container[i];
}
delete[] container;
for (int i=cellcount; i<cellcount+Vector.size(); i++)
{
newcontainer[i]=Vector[cellcount-Vector.size()];
}
container=new type[cellcount+Vector.size()];
for (int i=0; i<cellcount+Vector.size(); i++)
{
container[i]=newcontainer[i];
}
delete[] newcontainer;
cellcount+=Vector.size();
}
else
{
container=new type[Vector.size()];
for (int i=0; i<Vector.size(); i++)
{
container[i]=Vector[i];
}
cellcount=Vector.size();
}
}
}
kiedy wywołam funkcję add to obiekt który dodaję się "rozwala" czyli ma jakąś losową wartość. Jednak obiekt do którego dodaje dostaje za każdym razem poprawną wartość... dopiero potem gdy odwrotnie dodaje to się wszystko rozwala. nie rozumiem jak mogę zmieniać obiekt operując na jego kopii
1
Zakładając że nie interesują Cię wycieki pamięci:
template<typename type>class vector
{
private:
type *container;
public:
void add( const vector <type> &Vector )
{
if (container!=NULL)
{
type *newcontainer=new type[cellcount+Vector.size()];
std::copy ( container, container+cellcount, newcontainer );
delete[] container;
std::copy ( Vector.container, Vector.container + Vector.size(), newcontainer + cellcount);
container = newcontainer;
cellcount+=Vector.size();
}
else
{
container=new type[Vector.size()];
std::copy ( Vector.container, Vector.container + Vector.size(), container);
cellcount=Vector.size();
}
}
}
0
ale vector nie ma begin i end
0
oto poprawiona działająca wersja mojego wektora z niepotrzebnymi dodatkami :)
namespace niktech
{
template<typename type>class vector
{
private:
int cellcount;
type *container;
public:
int size()
{
if (container!=NULL)
{
return cellcount;
}
return 0;
}
void setsize(int new_size)
{
int old_size=0;
if (container!=NULL)
{
old_size=size();
type *newcontainer;
if (old_size>new_size)
{
old_size=new_size;
}
newcontainer=new type[old_size];
for (int i=0; i<old_size; i++)
{
newcontainer[i]=container[i];
}
delete[] container;
container=new type[new_size];
cellcount=new_size;
for (int i=0; i<old_size; i++)
{
container[i]=newcontainer[i];
}
delete[] newcontainer;
}
else
{
container=new type[new_size];
cellcount=new_size;
}
}
void add(type variable)
{
if (container!=NULL)
{
type *newcontainer=new type[cellcount+1];
for (int i=0; i<cellcount; i++)
{
newcontainer[i]=container[i];
}
newcontainer[cellcount]=variable;
for (int i=0; i<cellcount+1; i++)
{
container[i]=newcontainer[i];
}
delete[] newcontainer;
cellcount++;
}
else
{
container=new type[1];
container[0]=variable;
cellcount=1;
}
}
void add( vector <type> Vector )
{
if (container!=NULL)
{
type *newcontainer=new type[cellcount+Vector.size()];
for (int i=0; i<cellcount; i++)
{
newcontainer[i]=container[i];
}
delete[] container;
for (int i=cellcount; i<cellcount+Vector.size(); i++)
{
newcontainer[i]=Vector[i-cellcount];
}
container=new type[cellcount+Vector.size()];
for (int i=0; i<cellcount+Vector.size(); i++)
{
container[i]=newcontainer[i];
}
delete[] newcontainer;
cellcount+=Vector.size();
}
else
{
container=new type[Vector.size()];
for (int i=0; i<Vector.size(); i++)
{
container[i]=Vector[i];
}
cellcount=Vector.size();
}
}
type take_back()
{
type variable=(type)NULL;
if (container!=NULL)
{
variable=container[cellcount-1];
type *newcontainer=new type[cellcount-1];
for (int i=0; i<cellcount-1; i++)
{
newcontainer[i]=container[i];
}
delete[] container;
cellcount--;
container=new type[cellcount];
for (int i=0; i<cellcount; i++)
{
container[i]=newcontainer[i];
}
delete[] newcontainer;
}
return variable;
}
type take_back(int elements)
{
type variable=(type)NULL;
if (container!=NULL)
{
variable=container[cellcount-1];
type *newcontainer=new type[cellcount-elements];
for (int i=0; i<cellcount-elements; i++)
{
newcontainer[i]=container[i];
}
delete[] container;
cellcount-=elements;
container=new type[cellcount];
for (int i=0; i<cellcount; i++)
{
container[i]=newcontainer[i];
}
delete[] newcontainer;
}
return variable;
}
vector<type>take_all()
{
vector<type>returned;
for (int i=0; i<cellcount; i++)
{
returned.add(container[i]);
}
delete[] container;
cellcount=0;
return returned;
}
void remove_elements(int first,int last)
{
int index=0;
if (first>last)
{
index=last;
last=first;
first=index;
index=0;
}
last=(last<cellcount)*last+(last>=cellcount)*(cellcount-1)+0;
first=(first>=0)*first+0;
int count=last-first+1;
type *newcontainer=new type[cellcount-count];
for (int i=0; i<cellcount; i++)
{
if (i<first or i>last)
{
newcontainer[index]=container[i];
index++;
}
}
delete[] container;
cellcount-=count;
container=new type[cellcount];
for (int i=0; i<cellcount; i++)
{
container[i]=newcontainer[i];
}
delete[] newcontainer;
}
vector<type>object()
{
vector <type> returned;
for (int i=0; i<cellcount; i++)
{
returned.add(container[i]);
}
return returned;
}
type & operator[] (const int index)
{
return container[index];
}
vector<type> & operator=(vector<type> variable)
{
delete[] container;
cellcount=variable.size();
container=new type[cellcount];
for (int i=0; i<cellcount; i++)
{
container[i]=variable[i];
}
return *this;
}
vector()
{
container=NULL;
cellcount=0;
}
vector(int celcount)
{
container=new type[celcount];
cellcount=celcount;
}
~vector()
{
delete[] container;
cellcount=0;
}
};
};
może komuś się przyda, może nie ale przynajmniej się nauczyłem szablonów klas i przeciąrzania operatorów :)