017
10.01.2005, 17:50 Uhr
(un)wissender
Niveauwart
|
Habe ich das nicht gesagt?
Das ist der Funktionsprototyp:
| C++: |
template <class Typ>
std::ostream& operator<<(std::ostream&,const newVector<Typ>&);
|
Das hier ist eine Spezielisierung für alles , macht hier keinen Sinn, aber mit freind schon, sieht meine vorherige Erklärung.
| C++: |
template <class Typ>
//friend
std::ostream& operator<< <>(std::ostream&,const newVector<Typ>&);
|
z.B könnten ich auch schreiben, dann wäre es nur für ints
| C++: |
template <>
std::ostream& operator<< <int>(std::ostream&,const newVector<int>&);
|
Hier vielleicht nochmal mit int-Spezi zum ansehen, hier wird auch deutlich, dass die Für-alles-friend-Deklaration auch für ints gilt.
| C++: |
emplate <class Typ>
class newVector;
template <class Typ>
std::ostream& operator<<(std::ostream&,const newVector<Typ>&);
template <>
std::ostream& operator<< <int>(std::ostream&,const newVector<int>&);
template <class Typ>
class newVector{
public:
newVector();
~newVector();
newVector(std::size_t n);
newVector(const newVector& v);
Typ& operator[](int index);
const Typ& operator[](int index) const;
newVector& operator=(const newVector& v);
const newVector operator+(const newVector& v) const;
friend std::ostream& operator<< <>(std::ostream&,const newVector<Typ>&);
private:
void assign(const newVector<Typ>&);
Typ* v;
size_t n;
};
template <class Typ>
void newVector<Typ>::assign(const newVector<Typ>& vec)
{
Typ* temp = new Typ[vec.n];
std::copy(vec.v, vec.v + vec.n, temp);
std::swap(temp, v);
delete [] temp;
n = vec.n;
}
template <class Typ>
newVector<Typ>::newVector()
{
v = 0;
n = 0;
}
template <class Typ>
newVector<Typ>::newVector(std::size_t n)
{
this->n=n;
this->v=new Typ[n];
std::fill(v, v + n, 0);
}
template <class Typ>
newVector<Typ>::~newVector()
{
delete [] v;
}
template <class Typ>
newVector<Typ>::newVector( const newVector& v)
{
this->v = 0;
assign(v);
}
template <class Typ> Typ&
newVector<Typ>::operator[](int index)
{
return this->v[index];
}
template <class Typ>
const Typ& newVector<Typ>::operator[](int index) const
{
return this->v[index];
}
//war nicht exceptionsicher!
template <class Typ>
newVector<Typ>& newVector<Typ>::operator=(const newVector<Typ>& v)
{
assign(v);
}
template <class Typ>
const newVector<Typ> newVector<Typ>::operator+(const newVector<Typ>& v) const
{
//Hier Exception, wenn n != v.n
newVector rv(*this);
std::transform(rv.v, rv.v + rv.n, v.v, rv.v, std::plus<Typ>());
return rv;
}
template <class Typ>std::ostream& operator<<(std::ostream& os, const newVector<Typ>& v)
{
for(int i=0;i<v.n;++i)os<<v[i]<<" ";os<<std::endl;return os;
}
template <> std::ostream& operator<< <int>(std::ostream& os, const newVector<int>& v)
{
os << "int\n";
for(int i=0;i<v.n;++i)os<<v[i]<<" ";os<<std::endl;return os;
}
int main() {
int i;
newVector<int> a(3), b(3), d;
for(i=0; i<3; i++)
a[i] = b[i] = i;
d = a + b;
newVector<int> c(a);
std::cout << d;
std::cout << c;
}
|
--
Wer früher stirbt ist länger tot. |
