SystemC

hatte keine von euch ein idee?

danke

groovemaster

Du hast also einen Multiplier, der a und b als Parameter bekommt. Dass es n Multiplier gibt ist erstmal unwichtig, denn ich vermute mal, dass jeder Multiplier a und b als Parameter bekommt.
Damit nun operator * von sc_errint aufgerufen wird, muss, wie bereits erwähnt, a und b vom Typ sc_errint sein. Falls dies nicht möglich ist, kannst du immer noch temporäre Objekte muliplizieren

ergebnis = sc_errint<wasauchimmmer>(a) * sc_errint<wasauchimmmer>(b);

Sollte sc_int keinen operator int() haben, dann brauchst du übrigens noch einen passenden sc_errint ctor.

sc_errint(const sc_int<T>& source)
    : sc_int<T>(source)
{
}

Ansonsten versteh ich nicht so ganz, wo genau dein Problem liegt, bzw was nicht so funktioniert wie du dir das vorstellst.

btw:
Weil wir gerade das Thema in einem anderen Thread hatten, es ist durchaus sinnvoller, operator * ausserhalb der Klasse zu definieren.

template <int T>
sc_errint<T> operator *(const sc_errint<T>& lhs, const sc_errint<T>& rhs)
{
    const sc_int<T>& l = lhs;
    const sc_int<T>& r = rhs;
    return l * r + rand();
}

danke...

die klasse ist bereits erfolgreich abgeleitet da musste noch ein leerer Konstrultor rein.

nun habe ich folgendes problem:

nachdem ich den * erfolgreich überladen habe, wird im programm das normale * benutzt also nicht das überladene. obwohl a und b vom typ sc_errint definiert sind.

hast du vielleicht nen gedankenstoß?

groovemaster

the_one schrieb:

nachdem ich den * erfolgreich überladen habe, wird im programm das normale * benutzt also nicht das überladene

Das muss ja nicht zwangsläufig falsch sein, wenn zB operator * von sc_errint den operator * von sc_int aufruft. Bist du dir wirklich sicher, dass nur der operator * von sc_int aufgerufen wird? Mach mal irgendeine Ausgabe in beide Operatore, wie zB

std::cout << "operator * von bla aufgerufen" << std::endl;

oä, um wirklich sicher zu gehen.

Ansosnten, zeig mal die Definition von a und b, und die Stelle, wo beide multipliziert werden.

die definition von a und b :

sc_in< sc_errint<4> > a;
sc_in< sc_errint<4> > b;
sc_out< sc_errint<8> > c;

multiplikation

c.write(a.read() * b.read());

habe es auch mit :

c=a*b;

und

c.write(sc_errint<8>(a.read()* b.read());

aber gibt genau dieseselben ergebnisse

und das mal wird sicher von der sc_int klasse übernommen nicht von der sc_errint

groovemaster

the_one schrieb:

habe es auch mit :

c=a*b;

Dass das nicht funktioniert ist klar. a und b sind vom Typ sc_in, dann musst du schon schaun, was operator * von sc_in macht. Falls es überhaupt einen gibt.

the_one schrieb:

c.write(a.read() * b.read());

OK, in dem Fall muss man den Rückgabetyp von read() kennen.

sc_in und sc_out stehen jeweils für eingang und ausgang..das sagt nichts über den typen aus..

mit c.write(a.read() * b.read()) klapt es leider nicht

groovemaster

the_one schrieb:

sc_in und sc_out stehen jeweils für eingang und ausgang..das sagt nichts über den typen aus..

Doch, das tut es. a und b sind nunmal vom Typ sc_in<...>, dh heisst, du musst bei dessen operator * nachschaun was passiert, wenn du a * b rechnest.

the_one schrieb:

mit c.write(a.read() * b.read()) klapt es leider nicht

Nichts neues. Du solltest dir eigentlich den Rückgabetyp von read() anschaun, um den verwendeten Operator zu spezifizieren.

Offensichtlich fehlen dir einige C++ Grundkenntnisse. Vielleicht wäre es besser, wenn du dir erstmal ein gutes Tutorial über Operatoren anschaust, bevor du mit SystemC weitermachst.

endlich geschafft..

also jetzt wird der neue operator angenommen und angewendet..
die überladung muss so heissen:

template <int T> 
sc_errint<2*T> operator *(const sc_errint<T>& lhs, const sc_errint<T>& rhs) 
{ 
    const sc_int<T>& l = lhs; 
    const sc_int<T>& r = rhs; 
    return l * r + rand(); 
}

und die konstrukturen so :

sc_errint() : sc_int<T>() {} 
sc_errint(const sc_int<T>& source):sc_int<T>(source) {}

jetzt würde ich innerhalb dieses operator einzelne bits abändern zum beispiel
aus 1001 * 1101 würde ich 1011*1001 haben..die bitänderung soll zufällig erfolgen..

hast du ne idee?

groovemaster

the_one schrieb:

jetzt würde ich innerhalb dieses operator einzelne bits abändern zum beispiel
aus 1001 * 1101 würde ich 1011*1001 haben..die bitänderung soll zufällig erfolgen..

hast du ne idee?

Dafür kannst du die bitweise arbeitenden Operatoren benutzen << >> & | ^
Diese musst du dann halt nur noch mit einer gewissen Strategie auf den Wert des linken und rechten Operanden loslassen.
Seh ich das richtig, dass du zB die Reihenfolge der Bits invertieren möchtest? Leider gibt es dafür keine native Möglichkeit. Aber sowas kann man mit Hilfe einer Schleife relativ einfach selbst machen.