W
Daniel1985 schrieb:
besteht noch die möglichkeit noch sich den code snippsel in c++ mal anzuschauen??
Hallo Daniel1985,
willkommen im C++-Forum,
wie bist Du denn auf diesen alten Thread gestoßen?
Ich habe den Code noch gefunden, Du brauchst dazu noch die boost.lib für die Vektor-Klasse, die ich da verwende. Man könnte aber auch ohne auskommen. Hier der Hauptteil:
#include "vector2.h"
#include <algorithm> // std::max
#include <cmath> // std::abs
#include <iostream>
#include <string>
template< char C >
std::istream& Char( std::istream& in )
{
char c;
if( in >> c && c != C )
in.setstate( std::ios_base::failbit );
return in;
}
// -- Vektor Einlesen
template< typename T >
std::istream& operator>>( std::istream& in, basic_vector< T >& v )
{
T x, y;
if( in >> Char<'('> >> x >> Char<';'> >> y >> Char<')'> )
v = basic_vector< T >( x, y );
return in;
}
typedef basic_vector< double > Koordinate;
namespace
{
const double EPS = 1.E-8;
const double PI = std::acos( -1.0 );
}
bool gleich( double a, double b )
{
return std::abs( a - b ) < EPS;
}
bool kollinear( Koordinate a, const Koordinate& b )
{
// -- das Kreuzprodukt sollte ==0 sein
return std::abs( a % b ) < EPS;
}
double winkel( Koordinate a, const Koordinate& b )
{
return std::atan2( a % b, a * b );
}
class Viereck
{
public:
Viereck() {}
friend bool eine_diagonalen_halbiert_die_andere( const Viereck& v )
{
// oder anders ausgedrückt: liegt der Mittelpunkt einer Diagonalen
// auf der anderen, so wird erstere halbiert
return kollinear( (v.m_ecke[1] + v.m_ecke[3])/2 - v.m_ecke[0], v.e() )
|| kollinear( (v.m_ecke[2] + v.m_ecke[0])/2 - v.m_ecke[1], v.f() );
}
friend bool hat_innkreis( const Viereck& v )
{
// ein Viereck hat einen Inkreis, wenn die Summen der gegenüberliegenden
// Seitenpaare gleich sind
return gleich( abs( v.a() ) + abs( v.c() ), abs( v.b() ) + abs( v.d() ) );
}
friend bool seitenpaar_parallel( const Viereck& v )
{
// eine Seitenpaar ist parallel, wenn die Seitenvektoren
// kollinear sind.
return kollinear( v.a(), v.c() ) || kollinear( v.b(), v.d() );
}
friend bool hat_umkreis( const Viereck& v )
{
// ein Viereck hat einen Umkreis, wenn die Summe zweier gegenüberliegenden
// Winkel ==180 Grad beträgt.
return gleich( winkel( v.a(), -v.d() ) + winkel( v.c(), -v.b() ), PI /*180 Grad*/ );
}
friend std::istream& operator>>( std::istream& in, Viereck& v )
{
return in >> v.m_ecke[0] >> v.m_ecke[1] >> v.m_ecke[2] >> v.m_ecke[3];
}
private:
Koordinate a() const { return m_ecke[1] - m_ecke[0]; }
Koordinate b() const { return m_ecke[2] - m_ecke[1]; }
Koordinate c() const { return m_ecke[3] - m_ecke[2]; }
Koordinate d() const { return m_ecke[0] - m_ecke[3]; }
Koordinate e() const { return m_ecke[2] - m_ecke[0]; }
Koordinate f() const { return m_ecke[3] - m_ecke[1]; }
Koordinate m_ecke[4];
};
std::string typ_von( const Viereck& v )
{
const char* text[] = {
"allgemeines Viereck", // ....
"schiefer Drache", // H...
"Tangentenviereck", // .I..
"Drache", // HI..
"Trapez", // ..P.
"Parallelogramm", // H.P.
"Trapez mit Innkreis", // .IP.
"Raute", // HIP.
"Sehnenviereck", // ...U
"schiefer Drache mit Umkreis", // H..U
"Sehnentangentenviereck", // .I.U
"rechtohriger Drache", // HI.U
"symmetrisches Trapez", // ..PU
"Rechteck", // H.PU
"symmetrisches Trapez mit Innkreis", // .IPU
"Quadrat" // HIPU
};
return text[
((eine_diagonalen_halbiert_die_andere( v )? 1: 0) << 0) // H
+ ((hat_innkreis( v )? 1: 0) << 1) // I
+ ((seitenpaar_parallel( v )? 1: 0) << 2) // P
+ ((hat_umkreis( v )? 1: 0) << 3) // U
];
}
int main()
{
using namespace std;
cout << "geben Sie bitte ein Viereck ein (Ende mit 'q')" << endl;
cout << "Format: (2;1) (8;3) (7;6) (1;4)" << endl;
for( Viereck v; cout << "\n> ", cin >> v; )
cout << "Das Viereck ist ein " << typ_von( v ) << endl;
return 0;
}
.. und die Vektor-Klasse (siehe auch hier)
Die Datei "vector2.h":
#ifndef SAM_VECTOR2_H_
#define SAM_VECTOR2_H_
#include <boost/operators.hpp>
#include <iosfwd>
#include <cmath>
template< typename T >
class basic_vector :
boost::additive< basic_vector< T >,
boost::multiplicative2< basic_vector< T >, T
> >
{
public:
typedef T value_type;
basic_vector()
: m_x(0), m_y(0)
{}
basic_vector( value_type x, value_type y )
: m_x( x ), m_y( y )
{}
basic_vector& operator+=( const basic_vector& b )
{
m_x += b.m_x;
m_y += b.m_y;
return *this;
}
basic_vector& operator-=( const basic_vector& b )
{
m_x -= b.m_x;
m_y -= b.m_y;
return *this;
}
value_type operator*( const basic_vector& b ) const
{ // Skalarprodukt
return m_x * b.m_x + m_y * b.m_y;
}
basic_vector& operator*=( value_type f )
{
m_x *= f;
m_y *= f;
return *this;
}
basic_vector& operator/=( value_type f )
{
// Bem.: die Multiplikation mit dem Kehrwert von 'f' ist signifikant schneller als
// die Division der drei Koordinaten durch 'f'
return *this *= value_type(1) / f;
}
value_type operator%( const basic_vector& b ) const
{ // Kreuzprodukt in 2D -> Skalar
return m_x * b.m_y - m_y * b.m_x;
}
friend value_type abs( const basic_vector& v )
{
using namespace std;
return sqrt( v.m_x * v.m_x + v.m_y * v.m_y );
}
basic_vector operator-() const
{
return basic_vector( -m_x, -m_y );
}
private:
value_type m_x;
value_type m_y;
};
:xmas2: Werner
