also ich verstehe nicht ganz worum es in dem thread geht, klar gibts ne genauigkeitsbegrenzung bei der xten nachkommastelle, genauso wie ein int max ~2 milliarden als zahl speichern kann

man hat verschieden große variablen (1 byte, 4 byte, etc) und das wird halt binär so und so kodiert je nachdem ob die zahl positiv, negativ oder mit nachkommastellen ist

die zahlen die du da alle angegeben hast, ja die sind exakt darstellbar, bzw passen locker in 32 bit variablen rein ohne dass man was wegschnippeln müsste am nachkomma oder sie den wertebereich überschreiten

ka was die "32 bit darstellung" ist, 32 bit ist einfach der speicher den die variable zur verfügung hat, kann sein dass damit gemeint ist wie eine kommazahl in binär mit 32 bit aussieht

wie man das umrechnet weiß ich jedenfalls längst nicht mehr... vielleich findest du da was
http://en.wikipedia.org/wiki/Binary_numeral_system#Decimal

oha toll, hab diese suchseiten nicht gekannt, danke

weiß jemand ob es das buch in der bücherei bei der uni gibt oder kennt irgend ne bücherei wo man sich das ausborgen könnte?

hm hm du meinst alle funktionen die vor der main waren einfach in die .h datei getan und dann die .h in der main inkludiert

ja, ich würd das schon ein modul nennen, allerdings macht man es im normalfall nicht so dass in den .h files funktionsdefinitionen stehen

ne funktion besteht eigentlich aus einer deklaration

int funktion();

und einer definition

int funktion()
{
    return 5;
}

zb so, man kann aber so wie du es gemacht hast vor der main bzw in der h file gleich die definition machen wodurch die funktionen auch gleich deklariert sind

aber im normalfall solltest du eine .h file schreiben mit den deklarationen und eine cpp file mit den definitionen also, in der h file

//vector.h
#ifndef VECTOR_H
#define VECTOR_H


typedef struct {
  double x;
  double y;
  double z;
} Vector;


Vector set( double vec[3] );
Vector add( const Vector *v1, const Vector *v2 );
void printVector( const Vector * v );


//usw


#endif

dazu eine cpp file

//vector .cpp
#include "vector.h"


Vector set( double vec[3] )
{
    Vector result;
    result.x = vec[0];
    result.y = vec[1];
    result.z = vec[2];
    return result;
}


Vector add( const Vector *v1, const Vector *v2 )
{
    Vector result;
    result.x = v1->x + v2->x;
    result.y = v1->y + v2->y;
    result.z = v1->z + v2->z;
    return result;
}


void printVector( const Vector * v )
{
    printf("%lf %lf %lf",v->x, v->y, v->z);
}

so gehört das, die h file enthält die funktionsdeklarationen, die cpp file die dazugehörigen definitionen

und in der main inkludierst du dann die .h file und benutzt die funktionen wie gewohnt

also im prinzip alles so wie du es gemacht hast nur die deklarationen von den definitionen getrennt in einer extra vector.cpp file und nicht gleich in der h file, der grund dafür ist dass du die vector.cpp dann auch kompilieren kannst und siehst was für fehler drin sind etc, aber in der .h file geht das nicht

wenn du aber keine lust hast lass es halt so, richtig ist es auf jeden fall

naja eigentlich nicht, eine lösung wäre zb

main()
{
    Vector v1, v2;
    Vector v3;
    double skalar;
    char op;


    
    printf("1. Vektor eingeben: ");
    scanf("%lf %lf %lf",&v1.x,&v1.y,&v1.z); 
    printf("Operator eingeben: ");
    scanf("%c", &op);


    if(op == '*')
    {
        printf("2. Skalar eingeben: ");
        scanf("%lf",&skalar);
    }
    else
    {     
        printf("2. Vektor eingeben: ");
        scanf("%lf %lf %lf",&v2.x,&v2.y,&v2.z);
    }


    switch(op)
    {
        case '+': v3 = add(&v1, &v2);
                  printVector(&v3);
                  break;
        case '-': v3 = sub(&v1, &v2);
                  printVector(&v3);
                  break;
        case '*': v3 = mult(skalar, &v2);
                  printVector(&v3);
                  break;
        case 'x': v3 = cross(&v1, &v2);
                  printVector(&v3);
                  break;
        case '.': skalar = dot(&v1, &v2);
                  printf("%lf",skalar);
                  break;
        default: printf("Falscher Operand!\n");
             return 1;
    }

einen vektor braucht man auf jeden fall, der wird eingelesen, dann der operator, wenn der op * ist lesen wir nen skalar ein ansonsten einen zweiten vektor, rest bleibt gleich

das ganze setzt natürlich vorraus der benutzer gibt keinen müll ein sondern nur die gültigen operatoren

ich hab das flushall() weggelassen, weiß leider nicht wofür das gut ist, ich glaub man braucht es garnicht

die pronix tutorials find ich gut hab sie auch mal gelesen, die scripten hier... die meisten typen an der uni sind einfach keine lehrer sondern machen das scheinbar als hobby oder ka, die können den stoff überhaupt nicht rüberbringen dementsprechend sind dann die scripten (ist mein eindruck bisher zumindest)

Vector v1, v2;
...
scanf("%lf %lf %lf", &v1.x, &v1.y, &v1.z);

so gehört es, mit -> greifst du auf elemente von variablen zu die pointer sind aber v1 und v2 sind in dem fall ganz normale variablen und keine pointer variablen also nimmt man den . operator

dann, all deine funktionen nehmen const Vector * als parameter zb

void printVector( const Vector * v )

und da wir gerade festgestellt haben deine v1 und v2 die du in der main definierst sind ganz normale variablen kannst du sie nicht einfach übergeben und sie werden automatisch von Vector zu Vector* (also ein zeiger auf eine vector variable)

ein zeiger zeigt auf eine speicheradresse von einer bestimmten form, Vector* zeigt auf speicher der form Vector und über den & operator holst du dir die speicheradresse von etwas

also wenn du funktionen wie printvektor aufrufst müssen die so aussehen
(in der main, oder wo auch immer die funktion aufgerufen wird)

printVector(&v1);

du könntest auch sowas machen wie

Vector *v1Pointer = &v1;
printVector(v1Pointer);

um mal klarzumachen wie der referenzierungsoperator (&) funktioniert, du bekommst einfach nen pointer (der ein zeiger auf eine speicheradresse von nem bestimmten typ ist) zurück, wenn du auf ein

int a;

das anwendest mit

&a

bekommst du einen pointer auf int also

int *

dann der letzte fehler, du hast kein result, ganz am ende

add(&v1, &v2);
printVector(&result);

das result ist nur innerhalb der funktion bekannt und die funktion liefert es wieder zurück allerdings nicht so dass es die variable irgendwie in der main definiert und auf ein mal kannst du sie verwenden, die funktion liefert einfach einen vektor zurück, so wie du es gemacht hast rufst du add auf, es liefert dir nen vektor der aber schwupps verloren ist weil du ihn nirgends abspeicherst und dann versuchst du printVector aufzurufen obwohl du garkeine variable namens result definiert hast, richtig würde es so aussehen

Vector v3;
v3 = add(&v1, &v2);
printVector(&v3);

du definierst erst in der main dass es einen Vector v3 gibt, dann wird v3 der rückgabewert der funktion zugewiesen, und dann v3 aussgeben

natürlich muss die variable nicht v3 heißen sondern du kannst sie nennen wie du willst

heh.. hier gibts wohl nicht viele c# fans oder *g*
ich kenne zwar nur c, cpp, java und c# und ganz wenig rebol aber ich finde c# lässt keine wünsche offen, es ist einfach alles drin was man braucht, schnell, gut lesbar

genau, und dot mult und set sehen richtig aus

Zitat von sauzachn

Nein, es gibt ein paar Unterschiede. Das wichtigste ist, dass du mit Referenzen nicht so viel Blödsinn machen kannst. Z.b. kannst du einen Zeiger ohne Weiteres umbiegen, eine Referenz aber nicht mehr, nachdem sie einmal worauf "zeigt". Das ist genau das, was man bei Funktionsparametern in 99.9% der Fälle will.

jep aber zeiger selbst sind value types, wenn ich ihn also an die fkt übergebe bekommt sie ja blos ne kopie vom zeiger und selbst wenn sie den verändert bleibt er außerhalb der funktion gleich

außer ich übergebe nen zeiger oder referenz auf meinen zeiger dann kann die funktion ihn verhauen aber wenn ich nen zeiger auf nen zeiger übergebe dann will ich wahrscheinlich dass die funktion ihn auf neuen speicher zeigen lässt und ihn ändert

also ist es im endeffekt wieder dasselbe wie ne referenz wenn ich es in dem zusammenhang mit der funktion verwende?! ich hab mir das immer so vorgestellt

ja klar kann man x*x, y*y etc elementweise 2 vektoren multiplizieren aber soweit ich weiß ist das nirgends standardisiert dass v1*v2 gerechent wird indem v3.x = v1.x * v2.x usw oder?

ich würd auch referenzen nehmen weil man mit denen besser arbeiten kann aber wieso meinst du er sollte sie jetzt statt den pointern hier verwenden, im endeffekt ist es ja fast dasselbe

Zitat von sauzachn

(..)Wobei man das in OO-Sprachen eigentlich nicht so schreibt! Der Vektor, zu dem man addiert, sollte der durch die aktuelle Instanz festgelegte sein (also v2 weglassen und v1 zum aktuellen Vektor addieren). Das, was du machst, ist Java-Library-Stil, hat aber mit OO nix zu tun.

wieso er das so macht?.. weil es seine aufgabenstellung ist vielleicht es so zu machen? *g*

übrigens finde ich das immer noch objekt orientiert, die directx vektor klasse zb hat überladene +=, -=, etc operatoren, dazu funktionen wie Add(), Normalize() etc die direkt auf den vektor zugreifen aber auch statische funktionen in der form von denen da oben die nen neuen vektor liefern die in vielen situationen auch nützlich sind

also, zu vektorrechnung gibts schon zig hunderte libs im internet wo man sich das anschauen kann in allen sprachen da man das für grafikprogrammierung braucht

Zitat

Wieso heisst es bei der Multiplikation
Vector mult( double value, const Vector *v2 );
und nicht
Vector mult( const Vector *v1, const Vector *v2 );

weil man 2 vektoren nicht miteinander multiplizieren kann, das ist nicht irgendwie festgelegt deswegen wird hie rmit einem skalar multipliziert, das ergebnis soll einfach sein

v2->x * value, v2->y * value, v2->z * value

dann

Zitat

Und was ist dann
Vector dot( const Vector *v1, const Vector *v2 );
?

das punktprodukt, wird verwendet für den winkel zwischen zwei vektoren, ich glaube du musst dich da verschrieben haben weil die fkt einen vektor zurück gibt aber das punktprodukt ist ein skalar

berechnung sieht so aus

float dot(D3DVECTOR& v1, D3DVECTOR& v2) 
{
 return ( v1.x * v2.x + v1.y * v2.y + v1.z * v2.z );    
}

Zitat

Aber das ist nicht das Hauptproblem.
Sondern wie macht man dann die Eingabe Ausgabe?

ausgabe... naja einfach cout << "x: " << vec.x << " y: " << vec.y etc
einfach irgendwie ausgeben.. wenn du ne eingabe machen musst der reihe nach die elemente eingeben

Zitat

Und was kommt in das Modul scalar.h und was in scalar.c ?

ka du hast da in der fragestellung nichts nem modul skalar erwähnt... skalar ist einfach ein einziger float / double wert... wüsst nicht wofür man da ein extra modul bräuchte, hört sich unsinnig an

Zitat

Vector set( double vec[3] );

naja einfach

Vector set( double vec[3] )
{
  Vector newVector;
  newVector.x = vec[0];
  newVector.y = vec[1];
  newVector.z = vec[2];


  return newVector;
}

np

und zu:

Zitat von hal

(..) bei static_casts wird einfach dem Programmierer vertraut (was performance bringt).

das stimmt nicht ganz beim static_cast wird nicht "einfach dem programmierer vertraut"

sauz hat schon gesagt der static_cast ersetzt in fast allen fällen die c-casts aber so sachen wie das problem von dem thread oder das casten von streams wenn man zb in ne datei nen "int x" schreiben will kann man nicht einfach nen static_cast<char*>&x nehmen da spuckt der compiler fehler aus und man muss auf (char*) oder reinterpret_cast zurückgreifen

aber wie gesagt ich weiß nicht in wie fern sich c++ casts was bringen, ich hab sie ne zeit lang verwendet und dann bei c# waren sie auf ein mal weg, ich weiß nicht ob bei c# automatisch intern noch immer die richtigen casts (static, dynamic bei vererbten objekten usw) irgendwie zugeordnet werden ooder ob man sie einfach fallen gelassen hat, wäre interessant wenn das jemand wüsste

also ich habs nicht so mit den c++ casts aber in dem fall funktioniert ein static_cast nicht, mit einem reinterpret_cast müsste es gehen

ich weiß überhaupt nicht so richtig ob es sich bringt normalerweise c++ casts zu verwendet, außer vielleicht nen const_cast oder dynamic_cast in vererbungshierarchien ich denke static_casts kann man sich sparen und einfach die c casts verwenden

externe libs brauchst du nicht wirklich, die std hat so ziemlich (listen, strings, etc) was man braucht im normalfall

wenn du dann was spezielles brauchst wie ne lib für physik, vektormathematik, networking oder was auch immer schau dich einfach die entsprechenden libs die es dazu so gibt bei google an und such dir halt eine gute aus, ne liste mit "best of libs for xyz" kenn ich nicht *g*

classpath musst du nix eintragen weil die programme nicht über ne virtual machine ausgeführt werden müssen sondern die exe files direkt laufen

entwicklungsumgebung... jaja.. ne gratis entwicklungsumgebung, schwer zu sagen, am besten wäre einfach Visual Studio .NET wenn du es dir bei emule oder so runterladen würdest... wenn du mal irgnedwo in ner firma für windows was programmierst schätze ich mal wirst du dort auch irgend ne vs.net version wieder finden bzw müsste es an der uni vielleicht die express edition (eingeschränkte features usw) eigentlich um ein paar euro zu kaufen geben wenns auch windows und office usw für studenten gibt aber ich weiß es nicht

und hm ja.. c++ ist ne gute sprache, aber ich würd mir an deiner stelle durch den kopf gehen lassen doch c# zu lernen

ich mag zwar c++ besser als java obwohl ich zugebe dass java einfach besser ist weil es die objektorientierten konzepte einfach durchzieht und richtig umsetzt allerdings ist c# einfach noch ne ganze ecke besser in meinen augen, c# hat alle features die java auch hat und dazu noch sachen die es in java nicht gibt (zb delegates die ähnlich wie function pointer funktionieren und sich trotzdem in das objektorientierte konzept einfügen dass man damit nicht irgendwie mist bauen kann, durch delegates lassen sich eigene events definieren die man mit selbst geschriebenen event handlern abarbeiten kann, es gibt properties was ne elegante lösung ist die diesem ganzen set und get methoden haufen vorbeugt den man immer hat), es gibt in c# auch wie in java libs für alles, ich bin bei weitem nicht so gut dass ich sagen kann ich kenne alles aber ich hab einfach den eindruck dass es in c# besser umgesetzt ist zb die collections lib ist viel besser als die in java

abgesehen davon ist c# nur vernachlässigbar langsamer als c++ und beide sind sowieso viel schneller als java

ist es vor dem replace aufruf denn richtig geschrieben und erst durch das replace wird alles klein?
wenn es schon vorher klein ist dann schreib mal den codeschnipsel rein mit dem du den namen einliest

äh.. du verstehst glaub ich das konzept nicht, also erstmals

diese ganzen funktionen da wie trackbar1change usw, das sind events die aufgerufen werden wenn etwas passiert, wenn man also die position des balkens der trackbar1 verändert wird das change event aufgerufen, der parameter TObject sender ist wahrscheinlich das element von dem trackbar1 das child ist oder das parent window

du willst wahrscheinlich irgendwas machen wenn sich die trackbar ändert, zb lautstärke ändern etc, in deinem fall willst du bei label1 anzeigen an welcher position der slider steht

zunäst einmal ist TrackBar1->Max->Trackbar1->Position 100% falsch, zweitens versuchst du TrackBar1->Max->Trackbar1->Position = irgendwas in einer IntToStr() methode?!

man macht in den seltensten fällen zuweisungen im aufruf einer methode außer bei so sachen wie zb if(Succeeded(x = Initialize()))

also zunächst einmal, TrackBar1 ist ein objekt und hat attribute, die sind zb Min, Max, Position (wahrscheinlich) und wahrscheinlich hats noch sowas wie stepsize (spring ich um 1 oder mach 10er sprünge), enabled (kann ich den slider verschieben) und das attribut Max wird sicher ein integer oä sein aber keine klasse die schon garnicht als attribut noch eine TrackBar1 variable enthält -.-

du willst jetzt einfach dass das label die pos anzeigt, also wenn min = 0 und max=9 is und der slider sitzt in der mitte wird position = 5 sein und du willst dass in deinem label 5 steht... dann machst du einfach

void _fastcall TForm1::TrackBar1Change(TObject *Sender)
{
Label1->Caption = IntToStr(TrackBar1->Position);
}

und das wars.. ich meine bei dem mist der bei dir in der fkt steht setzt du die caption (den text) von deinem label auf

TrackBar1->Min

und weist den wert von TrackBar1->Min auf TrackBar1->Position zu (wenn man sich mal das falsche TrackBar1->Max->Trackbar1.. wegdenkt) bevor du das machst... also du setzt die position auf min und den text des labels auf min... -.-

und in der funktion da

void __fastcall TForm1::FormCreate(TObject *Sender)
{
Label1->Caption=StrToInt(TrackBar1->Max);    
}

beim createn von dem form setzt du die caption des labels auf max, aber ist die position der trackbar auch auf max? der default wert auf dem das beim starten steht ist wahrscheinlich wenn ich raten müsste entweder die mitte oder Min, jedenfalls würd ich da auch

Label1->Caption = IntToStr(TrackBar1->Position);

setzen

und am ende noch, zu deinem problem mit den kommazahlen und potenzen

wenn du kommazahlen zulassen willst dann wirst du wohl nicht StrToInt benutzen so wie beim addieren wie du es geschrieben hast sondern StrToFloat oder StrToDouble oder was auch immer die API für nen namen für die funktion hat, ein Int ist ganzzahlig und wenn in deiner textbox 1,23 steht dann wird das ,23 abgeschnitten, erst ein float oder double hat dann den wert 1,23

wenn du dein ergebnis hast und das ist 3,334 und du machst beim setzen in edit3 StrToInt dann wird wieder das nachkomma zeug abgeschnitten also musst du dann StrToFloat / sonst was machen... und das mit potenzieren

ja die funktion wird irgend sowas wie pow oder Pow heißen.. je nachdem was du verwendest, wenn du Math.h inkludierst dann hast du pow(x, y) -> x hoch y und du machst im

OnButtonPower
Edit3->Text = FloatToStr(pow(StrToFloat(Edit1->Text), StrToFloat(Edit2->Text));

es gibt allerdings auch eine LGPL, das l stand glaub ich zuerst für library und dann wurde es auf lesser geändert oder so

ist für libs gedacht, wenn man libs die unter lgpl sind verwendet muss man die software die diese lib verwendet nicht wieder komplett open source machen sondern (ka wie im detail) dann halt nur den library teil oder so... wollt nur erwähnen dass es die auch gibt

wenn du es komplett selbst geschrieben hast dann denke ich kannst du es auch ohne weiteres vertreiben wobei es zb bei visual studio so ist dass man die programme die mit der standard edition kompiliert worden sind nicht kommerziell vertreiben darf sondern erst wenn man es mit professional oder höher gemacht hat

wenn du vor hast deine software zu verkaufen würde ich mir noch erstmal anschauen wie es mit urheberrechten aussieht, es gibt vervielfältigungsrecht, nutzungsrecht, recht der urheberbezeichnung, recht der urheberschaft etc, du kannst beispielsweise die software komplett mit allen rechten verkaufen (außer die urheberschaft), oder nur das nutzungsrecht (die leute dürfen sie nur benutzen) oder nutzungs + vervielfältigungs (die leute dürfen es selbst weiterverkaufen also vervielfältigen) oder noch irgendwas dann können sie es auch modifizieren, ich bin auch kein experte auf dem gebiet aber sowas gibts dann halt

allerdings gibt es keine mechanismen die sowas automatisch erlauben weil man es einfach nie braucht... mir fällt zumindest kein fall ein wo es sinnvoll wäre dass man eine applikation schreibt die nur ein mal geöffnet werden kann

na gut einer fällt mir doch ein... sagen wir du willst zb für counter strike ne GUI schreiben zum editieren der cs config file.... -.-
das programm öffnet und liest die file automatisch ein um sie dann zu editieren und es hätte keinen sinn es ein zweites mal zu starten

allerdings brauchst du dann keine dummy file/port weil du ja schon überprüfen kannst ob die config file geöffnet ist

aber wann schreibt man schon so applikationen die sich auf nu reine file/port/was auch immer beschränken also, wäre interessant zu wissen wieso du denkst dass du sowas brauchst

mäh... na schön ich formuiere es mal um:

"du hast eine klasse mit einer variabel und du hast 2 weitere klassen die kopien oder referenzen auf diese variable haben und möchtest dass wenn sich eine der kopien oder referenzen verändert sich die variable in beiden klassen ändert"

ich nehme das mal so an weil er geschrieben hat er hat ptcDetector in A und 2 variablen ptcDetector_ in B und C

aber obwohl es so mit den pointern geht würde man es ganz sicher nicht so lösen sondern wie sauzachn gesagt hat, die variable in klasse A einfach nur ein mal abspeichern, B und C hätten eine referenz auf A und über A.Get/SetPtcDetector() greifen beide auf ptcDetector zu anstatt dass sie jeweils eine ptcDetector_ variable haben

alternativ wenn du keine referenz auf A in B und C haben willst kannst du ptcDetector in A static machen und über A::Get/SetPtcDetector() darauf zugreifen

Zitat von sauzachn

Code

for(int i=0,int j=10;i<j;i++,j--)
 printf("%d",i);

Ist allerdings auch der einzige Anwendungsfall, der mir einfällt. Meist in Verbindung mit Iteratoren gesehen.

aaaah, da wurde also dieser , operator benutzt

ich hab immer gedacht das ist einfach nur ne besondere implementierung bei for schleifen dass man das so machen kann und nicht weiter darüber nachgedacht, hab mich auch schon gefragt wieso das bei c# nicht mehr geht weil ichs vor ein paar wochen so machen wollte