---

Hej gruppe


Er der nogen der er i stand til at forklare hvad operatorerne:
operator* <>
operator| <>

gør godt for og hvorfor gcc 3.3 kan compile og forstå disse, mens en gcc
3.4 ikke kan???


Mvh / Preben

---

Preben wrote:
> Hej gruppe
>
>
> Er der nogen der er i stand til at forklare hvad operatorerne:
> operator* <>
> operator| <>
>
> gør godt for og hvorfor gcc 3.3 kan compile og forstå disse, mens en gcc
> 3.4 ikke kan???

Jeg bliver nok nødt til at få uddybet spørgsmålet.

Så vidt jeg kan se virker det fint:
#include <iostream>

class Int
{
public:
Int(int aI) : i(aI) {}
int i;
};

Int operator * (const Int& lhs, const Int& rhs)
{
return lhs.i * rhs.i;
}

Int operator | (const Int& lhs, const Int& rhs)
{
return lhs.i | rhs.i;
}

std::ostream& operator << (std::ostream& os, const Int& i)
{
os << i.i;
return os;
}

int main()
{
Int I1(1);
Int I2(2);
Int I3 = I1*I2;
Int I4 = I1|I2;
std::cout << I3 << std::endl;
std::cout << I4 << std::endl;
}

Med MinGW gcc version 3.4.2 skriver programmet som forventet
2 og 3

--
Just another homepage:
http://damb.dk
But it's mine - Bertel

---

>> Er der nogen der er i stand til at forklare hvad operatorerne:
>> operator* <>
>> operator| <>
>>
>> gør godt for og hvorfor gcc 3.3 kan compile og forstå disse, mens en gcc
>> 3.4 ikke kan???
>
> Jeg bliver nok nødt til at få uddybet spørgsmålet.

Undskyld den lange ventetid på et svar.
Der står sådan her i en header fil:

---------------
/** * scalar product */
Tcomp
operator * (const KVector<Tcomp>&) const;

/** * scalar multiplication */
friend KVector<Tcomp> operator * <>(const Tcomp r, const
KVector<Tcomp>&);
const KVector<Tcomp>& operator *= (const Tcomp);

/** / scalar division */
KVector<Tcomp>
operator / (const Tcomp r) const;
const KVector<Tcomp>&
operator /= (const Tcomp);

/** + add */
KVector<Tcomp>
operator + (const KVector<Tcomp>&) const;

/** - subtract */
KVector<Tcomp>
operator - (const KVector<Tcomp>&) const;


/** % cross product */
KVector<Tcomp>
operator % (const KVector<Tcomp>&) const;

/** & dot product */
KVector<Tcomp>
operator & (const KVector<Tcomp>&) const;

/** == equal */
int
operator == (const KVector<Tcomp>&) const;

/** != not equal */
int
operator != (const KVector<Tcomp>&) const;

/** author : Yiwen Zhang
last modified : 12. 4. 2000
state : working

| solve the system Ax=b,using LU decomposition. for example: x=A|b;
*/
friend KVector<Tcomp> operator| <>(const KMatrix<Tcomp>&, const
KVector<Tcomp>&);

/** dim() returns the dimension */
int dim() const;
---------------

> Så vidt jeg kan se virker det fint:
> #include <iostream>
>
> class Int
> {
> public:
> Int(int aI) : i(aI) {}
> int i;
> };
>
> Int operator * (const Int& lhs, const Int& rhs)
> {
> return lhs.i * rhs.i;
> }
>
> Int operator | (const Int& lhs, const Int& rhs)
> {
> return lhs.i | rhs.i;
> }
>
> std::ostream& operator << (std::ostream& os, const Int& i)
> {
> os << i.i;
> return os;
> }
>
> int main()
> {
> Int I1(1);
> Int I2(2);
> Int I3 = I1*I2;
> Int I4 = I1|I2;
> std::cout << I3 << std::endl;
> std::cout << I4 << std::endl;
> }
>

Men jeg kan heller ikke rigtig se, at du har anvendt operatorerne som
jeg har skrevet i første spørgsmål, men blot en multiplikator, en OR og
en streaming, hvilket er meget normalt set i mine øjne.

Som Rasmus også skriver kender han ikke til den operator - kan man
skrive sammensætninger af operatorer i en linie???

Hvor finder man en god oversigt over operatorer?



Med venlig hilsen

Preben Holm

---

Preben wrote:
>>> Er der nogen der er i stand til at forklare hvad operatorerne:
>>> operator* <>
>>> operator| <>
>>>
>>> gør godt for og hvorfor gcc 3.3 kan compile og forstå disse, mens en gcc
>>> 3.4 ikke kan???
>>
>> Jeg bliver nok nødt til at få uddybet spørgsmålet.
>
> Undskyld den lange ventetid på et svar.
> Der står sådan her i en header fil:
>
> ---------------
> /** * scalar product */
> Tcomp
> operator * (const KVector<Tcomp>&) const;
>
> /** * scalar multiplication */
> friend KVector<Tcomp> operator * <>(const Tcomp r, const
> KVector<Tcomp>&);

Jeg har aldrig set en *<> operator, og jeg kan ikke finde
den i C++ standarden.

Står denne kode inden i en class?

Du kunne forsøge at lave en:
typedef KVector<Tcomp> MyType;

Og ændre operatoren til:

friend MyType operator * <>(const Tcomp r, const MyType&);

Eller poste et komplet eksempel.

> Men jeg kan heller ikke rigtig se, at du har anvendt operatorerne som
> jeg har skrevet i første spørgsmål, men blot en multiplikator, en OR og
> en streaming, hvilket er meget normalt set i mine øjne.

Ja, det er de normale * | << operatorer jeg har brugt.

> Som Rasmus også skriver kender han ikke til den operator - kan man
> skrive sammensætninger af operatorer i en linie???

Ikke hvad jeg ved af.

> Hvor finder man en god oversigt over operatorer?

I C++ standarden.

--
Just another homepage:
http://damb.dk
But it's mine - Bertel

---

>> Undskyld den lange ventetid på et svar.
>> Der står sådan her i en header fil:
>>
>> ---------------
>> /** * scalar product */
>> Tcomp
>> operator * (const KVector<Tcomp>&) const;
>>
>> /** * scalar multiplication */
>> friend KVector<Tcomp> operator * <>(const Tcomp r, const
>> KVector<Tcomp>&);
>
> Jeg har aldrig set en *<> operator, og jeg kan ikke finde
> den i C++ standarden.
>
> Står denne kode inden i en class?

Ja, her er noget mere af header-filen:

--------------------
template<class Tcomp> class KVector {

int dimension; /** dimension */
Tcomp *v; /** pointer to components */

public:

friend class KClifford<Tcomp>;
friend class KMatrix<Tcomp>;
friend class KQuaternion;
friend class KCoordinate<Tcomp>;

KVector(); /** constructor leaves KVector undefined */
KVector(int d); /** KVector of dimension d */
KVector(const Tcomp a, const Tcomp b); /** two-dimensional KVector
(a, b) */
KVector(const Tcomp a, const Tcomp b, const Tcomp c); /**
three-dimensional KVector (a, b, c) */
KVector(const Tcomp a, const Tcomp b, const Tcomp c, const Tcomp d);
/** four-dimensional KVector (a, b, c, d) */
KVector(const KVector<Tcomp>&);
KVector(const std::vector< Tcomp > & vP); // vector of dimension 2, 3
or 4

KVector(const KMatrix<Tcomp>&);
KVector(const KQuaternion&);
KVector(const KCoordinate<Tcomp>&);
~KVector();

/** [] subscripting */
const Tcomp& operator [] (int i) const; /** reading */
Tcomp& operator [] (int i); /** writing */

/** KMatrix() value construction, type cast */
operator const KMatrix<Tcomp>() const;

/** KQuaternion() value construction, type cast */
operator const KQuaternion() const;

/** = simple assignment */
const KVector<Tcomp>&
operator = (const KVector<Tcomp>&);
const KVector<Tcomp>&
operator = (const KMatrix<Tcomp>&);
const KVector<Tcomp>&
operator = (const KQuaternion&);

/** = assigns KClifford number to KVector */
const KVector<Tcomp>&
operator = (const KClifford<Tcomp>&);

/** += add and assign */
const KVector<Tcomp>&
operator += (const KVector<Tcomp>&);

/** -= subtract and assign */
const KVector<Tcomp>&
operator -= (const KVector<Tcomp>&);

/** * scalar product */
Tcomp
operator * (const KVector<Tcomp>&) const;

/** * scalar multiplication */
friend KVector<Tcomp> operator * <>(const Tcomp r, const
KVector<Tcomp>&);
const KVector<Tcomp>& operator *= (const Tcomp);

/** / scalar division */
KVector<Tcomp>
operator / (const Tcomp r) const;
const KVector<Tcomp>&
operator /= (const Tcomp);

/** + add */
KVector<Tcomp>
operator + (const KVector<Tcomp>&) const;

/** - subtract */
KVector<Tcomp>
operator - (const KVector<Tcomp>&) const;


/** % cross product */
KVector<Tcomp>
operator % (const KVector<Tcomp>&) const;

/** & dot product */
KVector<Tcomp>
operator & (const KVector<Tcomp>&) const;

/** == equal */
int
operator == (const KVector<Tcomp>&) const;

/** != not equal */
int
operator != (const KVector<Tcomp>&) const;

/** author : Yiwen Zhang
last modified : 12. 4. 2000
state : working

| solve the system Ax=b,using LU decomposition. for example: x=A|b;
*/
friend KVector<Tcomp> operator| <>(const KMatrix<Tcomp>&, const
KVector<Tcomp>&);

/** dim() returns the dimension */
int dim() const;

/** init(v) initializes all components of the KVector with value v */
void init(Tcomp value);

/** calculate the euclidean norm
    @return the euclidean norm
*/
double norm() const;

/** normalize the vector ; after a call the vector has norm 1
*/
void normalize();

/** undef() undefines the KVector */
void undef();

/** def(d) (re)defines a KVector */
void def(int);

/** homog() returns the KVector v in homogene coordinates
(v0,...,vn,1); */
KVector<Tcomp> homog() const;

/** inhomog() returns the homogene KVector v in not homogene
coordinates (v0/vn,...,vn-1/vn); */
KVector<Tcomp> inhomog() const;

/** rotate the KVector v about axis about the angle alpha using
quaternions */
friend KVector<double> rotate(KVector<double>& v, KVector<double>&
axis, double alpha);

/** reading and writing of KVectors with preceding dimension for easy
data exchange */
std::ostream& write(std::ostream& strm) const;
std::istream& read(std::istream& strm);

/** >> input */
friend std::istream& operator >> <>(std::istream&, KVector<Tcomp>&);

/** << output */
   friend std::ostream& operator << <>(std::ostream& out, const
KVector<Tcomp>& w);
------------------------------------


og som det kan ses, bliver "<>"-tegnene også brugt ved streaming
operatorerne.

Det må have en eller anden betydning det der "<>"-halløj.


> Du kunne forsøge at lave en:
> typedef KVector<Tcomp> MyType;
>
> Og ændre operatoren til:
>
> friend MyType operator * <>(const Tcomp r, const MyType&);


>> Hvor finder man en god oversigt over operatorer?
>
> I C++ standarden.

Nu har jeg jo ikke så meget indblik i hele standarden. Har du et link,
mener bestemt der er en gratis udgave et sted.

Iøvrigt hvilke bøger ville du foreslå, hvis man har brug for en
forklarende bog om C++, men stadig ikke som "lærebog", men som
en opslagsbog.
Har brugt C++ i et års tid nu (ikke 8 timer om dagen, men langt mindre).
Mangler den ene (måske to) rigtig gode bog der kan fortælle mig det jeg
ikke ved eller har glemt.
Vil ikke sidde og læse hele kapitler som f.eks. "Sams Teach Yourself C++
in 21 days" - når alligevel aldrig særlig langt i den slags titler.



Med venlig hilsen
Preben

---

Preben wrote:
> friend KVector<Tcomp> operator * <>(const Tcomp r, const
Vector<Tcomp>&);

Så vidt jeg kan se, prøver den erklæring at gøre en enkelt instans af
et funktions-template til friend af en instans af et klasse-template.
Det ved jeg ærligt talt ikke om standard C++ overhovedet understøtter,
så det kan jo være en eksperimentel g++ extension, som de har fjernet
igen.

Et par "shotgun-debugging" forslag:

1. Fjern <> og se hvad der sker. Det gør syntaksen lovlig, men
formentlig virkningsløs, da den giver venskab til et
ikke-eksisterende overload af :erator*.
2. Brug template-specialiserings-syntaksen "template<>":
template <>
friend KVector<Tcomp> operator * (const Tcomp r,
const Vector<Tcomp>&);
Det bør sådan set heller ikke virke, da det er en instantiering,
ikke en specialisering, der skal gives venskab til.
3. Udvid venskabet til hele templatet:
template<typename Tcomp_>
friend KVector<Tcomp_> operator * (const Tcomp_ r,
const Vector<Tcomp_>&);
Jeg er ikke inde i de finere detaljer om hvordan friend med
templates fungerer, så jeg kan ikke garantere at det virker som
skrevet.

Der findes et hurtigt fix for at få det op at køre:
Gør alle medlemmer "public", og fjern eller udkommenter de
friend-erklæringer, der ikke vil oversætte.

Det bryder indkapslingen, og kan ikke anbefales som en permanent
løsning, men det kan måske hjælpe dig med til at komme videre indtil
rette vedkommende får rettet op på den headerfil.

>
> Iøvrigt hvilke bøger ville du foreslå, hvis man har brug for en
> forklarende bog om C++, men stadig ikke som "lærebog", men som
> en opslagsbog.

The C++ Programming Language af B. Stroustrup. Den er struktureret som
en opslagsbog, men formuleret som en lærebog, så jeg tror det er lige
sagen.

mvh. Anders

---

Preben wrote:
> og som det kan ses, bliver "<>"-tegnene også brugt ved streaming
> operatorerne.

> Det må have en eller anden betydning det der "<>"-halløj.

Det angiver normalt specialisering af en template. Har du f.eks. en
template funktion:
template<typename T> std::istream& operator >> (std::istream&, T&);

Så kan du lave en specialisering:
template<> std::istream& operator >> <>(std::istream&, KVector<Tcomp>&);

Men den kode du viser er ikke gyldig og jeg tror bare du skal fjerne <>.

>>> Hvor finder man en god oversigt over operatorer?
>>
>> I C++ standarden.
>
> Nu har jeg jo ikke så meget indblik i hele standarden. Har du et link,
> mener bestemt der er en gratis udgave et sted.

Du kan købe standarden som PDF-fil for $18 eller du kan hente en tidlig
udgave af standarden her:
ftp://ftp.research.att.com/pub/c++std/WP/CD2/

> Iøvrigt hvilke bøger ville du foreslå, hvis man har brug for en
> forklarende bog om C++, men stadig ikke som "lærebog", men som
> en opslagsbog.

Jeg vil anbefale:
Bjarne Stroustrup
The C++ Programming Language

Den gennemgår sproget fra ende til anden og er derfor rigtig god som
opslagsbog, men mindre god lærebog.

Kapitel §11.2 beskriver hvilke operatorer der kan overloades.

Ivan Johansen

---

>> og som det kan ses, bliver "<>"-tegnene også brugt ved streaming
>> operatorerne.
>
>> Det må have en eller anden betydning det der "<>"-halløj.
>
> Det angiver normalt specialisering af en template. Har du f.eks. en
> template funktion:
> template<typename T> std::istream& operator >> (std::istream&, T&);
>
> Så kan du lave en specialisering:
> template<> std::istream& operator >> <>(std::istream&, KVector<Tcomp>&);
>
> Men den kode du viser er ikke gyldig og jeg tror bare du skal fjerne <>.

Nej, åbenlyst ikke, men hvis jeg fjerner den del, får jeg flg.
--
friend KVector<Tcomp> operator* (const Tcomp r, const KVector<Tcomp>&)
--

og det giver flg. warning:

--
.../../../include/KVector.h:101: warning: friend declaration
'KVector<Tcomp> operator*(Tcomp, const KVector<Tcomp>&)' declares a
non-template function
.../../../include/KVector.h:101: warning: (if this is not what you
intended, make sure the function template has already been declared and
add <> after the function name here) -Wno-non-template-friend disables
this warning
--


og så er det jo lige spørgsmålet om hvad der er det rigtige?


Egentlig så går metoden:
friend KVector<Tcomp> operator| <>(const KMatrix<Tcomp>&, const
KVector<Tcomp>&);

fint nok igennem compileren, og jeg kan egentlig ikke rigtig se nogen
forskel på de to metoder set i forhold til operator*.


Hvad mener du gør koden "ugyldig"? Hvad skulle der stå for at være
gyldig mener du? Er det ikke en specialisering i template'n?


Mvh / Preben

---

Preben wrote:
> Er der nogen der er i stand til at forklare hvad operatorerne:
> operator* <>
> operator| <>

De C++ operatore kender jeg slet ikke... Og det ser heller ikke ud til at
C++ standarden gør. Det kan være at det er en fejl at gcc 3.3 overhovedet
kan sluge dem, og fejlen er rettet i gcc 3.4?
Og så vidt jeg ved er de eneste gcc-specifikke operatore >? og <?.

--
mvh Rasmus Neckelmann