spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

// wenn du das hier definierst...

float fnZ_1_P(int nZ_1_W, float fZ_1_R)
{
      float fWasserpegel;
      fWasserpegel = nZ_1_W/PI/(fZ_1_R*fZ_1_R);
      return fWasserpegel;
}

int main()
{
   [.,..]
    //   Kannst du das doch nicht so aufrufen O_X,

    // du musst schon die Werte übergeben...

    // Hast du ein C++-Buch? Wenn ja ->lies es :D

    // Besonders die Abschnitte Funktionen und Klassen.

    fZ_1_P = fnZ_1_P();
    cout << endl <<fZ_1_P<<endl;
    return 1;
}

C-/C++-Quelltext

#include <cmath>
#include <iostream>

#ifndef PI
#   define PI 3.14
#endif /* PI */

class Zylinder
{
private:
    Zylinder() {}

public:
    Zylinder(const float radius, const float inhalt)
    {
        m_inhalt = inhalt;
        m_radius = radius;
    }
    
    Zylinder(const Zylinder& z)
    {
        m_inhalt = z.m_inhalt;
        m_radius = z.m_radius;
    }

    virtual ~Zylinder() {}
    
    Zylinder& operator= (const Zylinder& z)
    {
        m_inhalt = z.getInhalt();
        m_radius = z.getRadius();
    }    
    
    float getInhalt() const { return m_inhalt; }
    float getRadius() const { return m_radius; }
    
private:
    float m_radius;
    float m_inhalt;
};    

class ZylinderRechner
{
public:
    ZylinderRechner() : m_ergebnis(0)
    {}
    
    virtual ~ZylinderRechner() {}
    
    ZylinderRechner(const ZylinderRechner& c)
    {
        m_ergebnis = c.m_ergebnis;
    }
    
    float rechne( const Zylinder& z )
    {
        m_ergebnis = (z.getInhalt() / PI) / (z.getRadius()  * z.getRadius() );
        return m_ergebnis;
    }
    
    float getErgebnis() const{ return m_ergebnis; }
    
    // Obey the rule of three.

    ZylinderRechner& operator=(const ZylinderRechner& c) 
    {
        m_ergebnis = c.m_ergebnis;
        return *this;
    }
    
private:
    float m_ergebnis;
};

int main()
{ 
    Zylinder zylinder = Zylinder(1.0f, 2.0f);
    ZylinderRechner rechner;
    float ergebnis = rechner.rechne(zylinder);
    std::cout << "Ergebnis: " << ergebnis << std::endl;
    // oder

    std::cout << "Ergebnis: " << rechner.getErgebnis() << std::endl;
    return 0;
}

C-/C++-Quelltext

#include <cmath> 
#include <iostream> 

//#ifndef PI 

//#   define PI 3,14 

//#endif /* PI */ 


static const float PI = 3.14f; // PUNKT nicht KOMMA!!!


class Zylinder 
{ 
private: 
    //inline Zylinder() {} // irrelevant


public:  
    /*inline braucht kein Mensch hier*/Zylinder(const float radius, const float inhalt) : m_inhalt( inhalt ), m_radius( radius )
    { 
        /*m_inhalt = inhalt; 
        m_radius = radius; => es gibt eine Initialisationsliste */ 
    } 
    
/* => WOZU braucht man hier so etwas?? Oo
    inline Zylinder(const Zylinder& z) 
    { 
        m_inhalt = z.m_inhalt; 
        m_radius = z.m_radius; 
    } */

    // inline virtual ~Zylinder() {} -> weg mit dem unnützen Zeug!

    
/* Auch unnötig
    inline Zylinder& operator= (const Zylinder& z) 
    { 
        m_inhalt = z.getInhalt(); 
        m_radius = z.getRadius(); 
    }    */
    
    /*inline weg*/ float getInhalt() const { return m_inhalt; } 
    /*inline weg*/ float getRadius() const { return m_radius; } 
    
private: 
    float m_radius; 
    float m_inhalt; 
};    

class ZylinderRechner 
{ 
public: 
    /*inline weg*/ ZylinderRechner() : m_ergebnis(0) 
    {} 
    
    //virtual inline  ~ZylinderRechner() {} 

    
    /* Unsinnig
     inline ZylinderRechner(const ZylinderRechner& c) 
    { 
        m_ergebnis = c.m_ergebnis; 
    } */
    
    /*inline */float rechne( const Zylinder& z ) 
    { 
        m_ergebnis = (z.getInhalt() / PI) / (z.getRadius()  * z.getRadius() ); 
        return m_ergebnis; 
    } 
    
    /*inline*/ float getErgebnis() const{ return m_ergebnis; } 
    
    // Obey the rule of three. => kannste hier vergessen

    /*inline ZylinderRechner& operator=(const ZylinderRechner& c) 
    { 
        m_ergebnis = c.m_ergebnis; 
        return *this; 
    } */
    
private: 
    float m_ergebnis; 
}; 

int main() 
{ 
    Zylinder zylinder = Zylinder(1.0f, 2.0f); 
    ZylinderRechner rechner; 
    float ergebnis = rechner.rechne(zylinder); 
    std::cout << "Ergebnis: " << ergebnis << std::endl; 
    // oder 

    std::cout << "Ergebnis: " << rechner.getErgebnis() << std::endl; 
    return 0; 
}

C-/C++-Quelltext

template< typename T, typename U >
T LexicalCast( const U& value )
{
    std::stringstream stream;
    T result;

    if ( !( stream << value && stream >> result && ( stream >> std::ws ).eof() ) )
        throw std::logic_error( "LexicalCast failed" );

    return result;
}

class MathConstants
{
public:
    static const float PI;
    static const float INV_PI;
};

const float MathConstants::PI = std::atanf( 1.0f ) * 4.0f;
const float MathConstants::INV_PI = 1.0f / PI;

class GeomObject
{
public:
    struct ParseError : std::exception
    {
        ParseError( const char* const& desc ) : std::exception( desc )
        {}
    };

    virtual ~GeomObject() {}

    virtual std::ostream& WriteToStream( std::ostream& stream ) const = 0;
    virtual std::istream& ReadFromStream( std::istream& stream ) = 0;

    friend std::ostream& operator<<( std::ostream& stream, const GeomObject& c )
    {
        return c.WriteToStream( stream );
    }

    friend std::istream& operator>>( std::istream& stream, GeomObject& c )
    {
        return c.ReadFromStream( stream );
    }
};

class Cylinder : public GeomObject
{
private:
    float mRadius;
    float mHeight;
    float mVolume;

public:
    Cylinder( float r = .0f, float h = .0f, float v = .0f )
        : mRadius( r )
        , mHeight( h )
        , mVolume( v )
    {}

    static Cylinder FromRadiusHeight( float r, float h )
    {
        return Cylinder( r, h, MathConstants::PI * r * r * h );
    }

    static Cylinder FromHeightVolume( float h, float v )
    {
        return Cylinder( std::sqrtf( v * MathConstants::INV_PI / h ), h, v );
    }

    static Cylinder FromRadiusVolume( float r, float v )
    {
        return Cylinder( r, v * MathConstants::INV_PI / ( r * r ), v );
    }

    std::ostream& WriteToStream( std::ostream& stream ) const
    {
        return ( stream << "r: " << mRadius << " h: " << mHeight << " v: " << mVolume );
    }

    std::istream& ReadFromStream( std::istream& stream )
    {
        static const char* parserLUT[] = 
        { 
            "r: ", 
            "h: ", 
            "v: " 
        };

        int i = 0;
        std::string line( "" );
        char c = 0;
        float v[ 3 ];
        
        while ( i < 2 )
        {
            std::getline( stream, line );

            for ( int j = 0; j < 3; ++j )
            {
                if ( line.compare( 0, 3, parserLUT[ j ] ) == 0 )
                {
                    c |= 1 << j;

                    try
                    {
                        v[ j ] = LexicalCast< float >( line.substr( 3 ) );
                    }
                    catch ( ... )
                    {
                        v[ j ] = 0.0f;
                    }
                    break;
                }
            }

            ++i;
        }

        if ( c & 0x1 && c & 0x2 )
        {
            *this = Cylinder::FromRadiusHeight( v[ 0 ], v[ 1 ] );
        }
        else if ( c & 0x1 && c & 0x4 )
        {
            *this = Cylinder::FromRadiusVolume( v[ 0 ], v[ 2 ] );
        }
        else if ( c & 0x2 && c & 0x4 )
        {
            *this = Cylinder::FromHeightVolume( v[ 1 ], v[ 2 ] );
        }
        else
        {
            throw new ParseError( "parsing failed" );
        }

        return stream;
    }
};

void ReadCylinderValue( const std::string& prompt, Cylinder& c )
{
    while ( true )
    {
        std::cout << prompt << std::endl;
        try
        {
            std::cin >> c;
        }
        catch ( ... )
        {
            std::cout << "Falsche Eingabe: Gueltig ist( kuerzel: <wert> wobei kuerzel sein kann (r:, h: oder v:))" << std::endl;
        }
    }
}

C-/C++-Quelltext

float fnZylinder_1_Wasser()
{
      float fWasser;
      cout << "Geben Sie an, wie viel Wasser in [ml] Zylinder 1 beinhaltet:  ";
      cin >> fWasser;
      while (fWasser < 0)
      {
            cout << "Die Menge an Wasser kann nicht negativ sein, bitte neue Eingabe:  ";
            cin >> fWasser;
      }
      return fWasser;
}

C-/C++-Quelltext

float fnZylinder_Wasser(const int index)
{
      float fWasser;
      cout << "Geben Sie an, wie viel Wasser in [ml] Zylinder " << index << " beinhaltet:  ";
      cin >> fWasser;
      while (fWasser < 0)
      {
            cout << "Die Menge an Wasser kann nicht negativ sein, bitte neue Eingabe:  ";
            cin >> fWasser;
      }
      return fWasser;
}