[Megoldva] Valami hasznalhato compiler a loser g++ helyett linuxra?

Lebegő pontos a kód ?

fixpontos. a muveleteket egy 4 integer membert (left, top, rigt, bottom) tartalmazo "rect" nevu classon kell vegezni. ezek egy stl::list-ben vannak tarolva, mivel ugyis szekvencialisan kell tudni nagyon gyorsan vegigmenni az osszesen, ez ujfent gyorsan kell tudni az egyik containerbol egy masikba atdobni az elemeket.

Milyen függvényeket hivogat ?

OS szinten? kb annyit amennyit a stl::list hiv, azaz memoriamanagement uj elem letrehozasakokr.

Templateket használsz benne ?

Meg annyi hogy a modul intenziven hasznal stl::list-et, szoval akar a linuxos (default) stl is lehet a hunyo.

szeinted? :-P

Több szálas ?

nem.

Lehet, hogy msvc hatalmas kodreszleteket kiegyeszerűsített a programodból ?

szinte kizartnak tartom. eleg egyszeru a kod en meg messze nem vagyok mar nullkilometeres c++-ban.

maga a feladat, egy nem elforgatott, adott esetben egymassal fedesben levo teglalapokkal lefedett terulet, nem fedesben levo teglalapokkal lefedese. sajnos nem jutott eszembe hatekonyabb megoldas mint a teglalapokat egyenkent hozzaadni a keszlethez, es minden hozzaadaskor optimalizalni a hozzaadott teglalapot (bizonyos esetekben ez csak az uj teglalapo ketteosztasaval oldhato meg)

a ket teglalap iptimalizaciojat a rect::optimize oldja meg, ezt hivja eleg sokat a rectset::addRect, amit a teszter hiv meghatarozott szamu random teglelappal.

itt van a rect es a rectset deklaracioja:

//rects.h (C) 2007 Body Attila, all rights reserved
#ifndef __RECTS_H_INCLUDED
#define __RECTS_H_INCLUDED

#include <vector>
#include <list>

namespace gfx
{
	class point
	{
	public:
		inline point( const point &pt ) : m_x(pt.m_x), m_y(pt.m_y) {}
		inline point( int nx, int ny ) : m_x(nx), m_y(ny) {}
		int	m_x;
		int	m_y;
	};

	class rect
	{
	public:
		enum RELATION {
			notints = 0,
			conts,
			contd,
			modded,
			split
		};

		rect( const rect &base );
		rect();
		rect( int left, int top, int right, int bottom );
//		virtual ~rect();
		
		rect&		operator=( const rect &other );
		bool		join( const rect &other );
		inline bool	operator==( const rect &other ) const
		{
			return
				m_top == other.m_top &&
				m_left == other.m_left &&
				m_bottom == other.m_bottom &&
				m_right == other.m_right;
		}
		inline bool operator!=( const rect &other ) const { return ! operator==(other ); }
		inline bool	contains( rect &other) const {
			return m_top <= other.m_top &&
				m_bottom >= other.m_bottom &&
				m_left <= other.m_left &&
				m_right >= other.m_right;
		}
		inline bool contains( int x, int y ) const {
			return x >= m_left && x <= m_right && y >= m_top && y <= m_bottom;
		}
		inline bool contains( point &pt ) { return contains( pt.m_x, pt.m_y ); }

		inline int	width() const { return m_right - m_left; }
		inline int	height() const { return m_bottom - m_top; }
		inline bool	isEmpty() const { return width() <=0 || height() <= 0; }
		inline int	getTop() const { return m_top; }
		inline int	getLeft() const { return m_left; }
		inline int	getBottom() const { return m_bottom; }
		inline int	getRight() const { return m_right; }
		bool		hasIntersection( rect &insct, const rect &rct ) const;
		RELATION	optimize( rect &nr, rect &r );
		rect&		operator+=( const point &offset );
		rect&		operator*=( int mul );

	protected:
		enum EDGES {
			top = 1,
			left = 2,
			bottom = 4,
			right = 8
		};

		int	m_left, m_top, m_right, m_bottom;
		static const unsigned char	m_edgecnt[16];
	};	//	class rect

	class rectset
	{
	public:
		typedef std::list<rect>		RECTLIST;
		typedef RECTLIST::iterator	RLIT;

		rectset();
		size_t addRect( rect &r );
		inline std::list<rect>& getList() { return m_rects; }

	protected:
		RECTLIST	m_rects;
	};

	bool chklst( rectset::RLIT &begin, rectset::RLIT &end, rectset::RLIT &r1, rectset::RLIT &r2 );


}	//	namespace gfx
#endif /*__RECTS_H_INCLUDED*/

itt meg a kod:

//rects.cpp (C) 2007 Body Attila, all rights reserved
#include "stdafx.h"

#include "gfx/rects.h"
#include "svgwriter.h"
#include <algorithm>
#include <sstream>

using namespace gfx;
using namespace std;

#pragma warning( disable : 4996 )

//////////////////////////////////////////////////////////////////////////////
rect::rect( const rect &base ) :
	m_top( base.m_top ),
	m_left( base.m_left ),
	m_bottom( base.m_bottom ),
	m_right( base.m_right )
{
}

//////////////////////////////////////////////////////////////////////////////
rect::rect() :
	m_top( 0 ),
	m_left( 0 ),
	m_bottom( 0 ),
	m_right( 0 )
{
}

//////////////////////////////////////////////////////////////////////////////
rect::rect( int left, int top, int right, int bottom ) :
	m_top( top ),
	m_left( left ),
	m_bottom( bottom ),
	m_right( right )
{
}

//rect::~rect()
//{
//}

//////////////////////////////////////////////////////////////////////////////
bool rect::hasIntersection( rect &insct, const rect &rct ) const
{
	insct.m_top = max( m_top, rct.m_top );
	insct.m_bottom = min( m_bottom, rct.m_bottom );
	insct.m_left = max( m_left, rct.m_left );
	insct.m_right = min( m_right, rct.m_right );
	
	
	return ( !insct.isEmpty() );
}

//////////////////////////////////////////////////////////////////////////////
rect& rect::operator=( const rect &other )
{
	m_top = other.m_top;
	m_left = other.m_left;
	m_bottom = other.m_bottom;
	m_right = other.m_right;
	return *this;
}

//////////////////////////////////////////////////////////////////////////////
bool rect::join( const rect &other )
{
	if( m_top == other.m_bottom && m_left == other.m_left && m_right == other.m_right ) {
		m_top = other.m_top;
		return true;
	}
	if( m_bottom == other.m_top  && m_left == other.m_left && m_right == other.m_right ) {
		m_bottom = other.m_bottom;
		return true;
	}
	if( m_left == other.m_right && m_top == other.m_top && m_bottom == other.m_bottom ) {
		m_left = other.m_left;
		return true;
	}
	if( m_right == other.m_left && m_top == other.m_top && m_bottom == other.m_bottom ) {
		m_right = other.m_right;
		return true;
	}
	return false;
}

//////////////////////////////////////////////////////////////////////////////
rect& rect::operator+=( const point &offset )
{
	m_left += offset.m_x;
	m_right += offset.m_x;
	m_top += offset.m_y;
	m_bottom += offset.m_y;
	return *this;
}

//////////////////////////////////////////////////////////////////////////////
rect& rect::operator*=( int mul )
{
	m_left *= mul;
	m_right *= mul;
	m_top *= mul;
	m_bottom *= mul;
	return *this;
}

//////////////////////////////////////////////////////////////////////////////
const unsigned char	rect::m_edgecnt[16] = {
//	0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
	0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4
};

//////////////////////////////////////////////////////////////////////////////
rect::RELATION rect::optimize( rect &nr, rect &r )
{
	if( !hasIntersection( nr, r ) )
		return notints;

	if( nr == r )
		return conts;

	if( nr == *this )
		return contd;

	unsigned char	edges(0), edges_wrk;

	//how many edges of the intersection rect equals to this rect
	if( nr.m_top == m_top )
		edges |= top;
	if( nr.m_left == m_left )
		edges |= left;
	if( nr.m_bottom == m_bottom )
		edges |= bottom;
	if( nr.m_right == m_right )
		edges |= right;

	if( edges ==( left|right ) ) {
		if( nr.m_top == r.m_top && nr.m_bottom == r.m_bottom && nr.m_left != r.m_left && nr.m_right != r.m_right ) {
			//see fig G. in spec.svg
			nr.m_right = r.m_right;
			r.m_right = nr.m_left;
			nr.m_left = m_right;
			return split;
		} else {
			//see fig A in spec.svg
			edges = nr.m_left == r.m_left ? right : left;
		}
	}
	else if( edges ==( top|bottom ) ) {
		if( nr.m_left == r.m_left && nr.m_right == r.m_right && nr.m_top != r.m_top && nr.m_bottom != r.m_bottom ) {
			//see fig. H in spec.svg
			nr.m_bottom = r.m_bottom;
			r.m_bottom = nr.m_top;
			nr.m_top = m_bottom;
			return split;
		} else {
			//see fig C in spec.svg
			edges = r.m_top == r.m_top ? bottom : top;
		}
	}

	rect	*rtm( NULL );
	switch( m_edgecnt[edges] )
	{
	case 3:	//3edgeb.svg
		rtm = this;
		edges_wrk = edges;
		break;
	case 1:	//3edgea.svg
		rtm =&r;
		edges_wrk = (~edges) & 0x0f;
		break;
	case 4:
		break;
	}

	if( rtm )
	{
		if( !(edges_wrk & top ) ) {
			//top is "free, so we modify the bottom (Fig. D on 3edges.svg)
			rtm->m_bottom = nr.m_top;
		} else if( !(edges_wrk & left) ) {
			//left is "free, so we modify the right (Fig. B on 3edges.svg)
			rtm->m_right = nr.m_left;
		} else if( !(edges_wrk & bottom ) ) {
			//bottom is "free, so we modify the top (Fig. C on 3edges.svg)
			rtm->m_top = nr.m_bottom;
		} else { // if( !(edges_wrk & right ) ) {
			//right is "free, so we modify the left (Fig. A on 3edges.svg)
			rtm->m_left = nr.m_right;
		}
		return modded;
	}
	else	//normal slice case: 2edge.svg
	{
		edges_wrk = (~edges) & 0x0f;
		if( edges_wrk & top ) {
			r.m_top = m_bottom;
		} else { //if( edges_wrk & bottom ) {
			r.m_bottom = m_top;
		}
		if( edges_wrk & left ) {
			nr.m_right = r.m_right;
			nr.m_left = m_right;
		} else { //if( edges_wrk & right ) {
			nr.m_left = r.m_left;
			nr.m_right = m_left;
		}
		return split;
	}
}

//////////////////////////////////////////////////////////////////////////////
rectset::rectset()
{
}

//////////////////////////////////////////////////////////////////////////////
size_t rectset::addRect( rect &r )
{
	RECTLIST	nrs;	//new rects
	RECTLIST	crs;	//rects in collision with the new rect;
	RECTLIST	ncrs;	//rect in not collision with the new rect;

	rect		tmprect;

	if( m_rects.empty() ) {
		m_rects.push_back( r );
		return 0;
	}

	while( m_rects.size() ) {
		RLIT	it( m_rects.begin() );
		if( it->hasIntersection( tmprect, r ) )
			crs.splice( crs.end(), m_rects, it );
		else
			ncrs.splice( ncrs.end(), m_rects, it );
	}

	size_t	retval( crs.size() );
	nrs.push_back( r );
	RLIT	crit( crs.begin() );

	rect::RELATION	lastrel( rect::notints );

	while( crit != crs.end() )
	{
		RLIT	nrit( nrs.begin() );
		while( nrit != nrs.end() )
		{
			RLIT	tmpit;
			lastrel = crit->optimize( tmprect, *nrit );
			switch( lastrel )
			{
			case rect::notints:
				//WTF?!
				break;

			case rect::conts:
				tmpit = nrit;
				++tmpit;
				nrs.erase( nrit );
				nrit = tmpit;
				break;

			case rect::contd:
				tmpit = crit;
				++tmpit;
				crs.erase( crit );
				crit = tmpit;
				break;

			case rect::split:
				//no need to check newly inserted rect against the same base rect
				nrs.insert( nrit, tmprect );
				break;

			case rect::modded:
				break;
			}
			if( lastrel != rect::conts )
				nrit++;
			if( lastrel == rect::contd )
				break;
		}	//	while( nrit != nrs.end() )
		if( lastrel != rect::contd )
			++crit;
	}	//	while( crit != crs.end() )
	m_rects.splice( m_rects.begin(), ncrs );
	m_rects.splice( m_rects.end(), crs );
	m_rects.splice( m_rects.end(), nrs );

	return retval;
}

Van meg kerdes?

compi@arwen-d32:~$ uname -a
Linux arwen-d32 2.6.23-rc8-k8i-pae #1 SMP PREEMPT Wed Sep 26 10:23:38 CEST 2007 i686 GNU/Linux
compi@arwen-d32:~$ gcc --version
gcc (GCC) 4.2.1 (Debian 4.2.1-3)

oke, pongyolan fogalmaztam. kb azt akartam mondani amit te irtal, bar szerintem nem szukseges a kozisztencia folytonos ellenorzese "eles" verzional, az ojjektum teszteleset viszont nagyban meg tudja konnyiteni, jelen esetben pedig az "eles" kornyezetben jelentos sebessegnovekedest lehetett volna vele elerni. de mind1, ebben az esetben szerencsere megkerulheto volt a size() hivasa.