Ein Asuro roboterbausatz ist gut geeignet um die C++ Grundlagen zu lernen.
Das interessiert mich jetzt doch! Warum findet man keine Beschreibungen über die Art der Durchführung und Beispielprogramme in C++ für den ASURO? Auf dem ATmega128 des Nibo ist C++ überhaupt kein Problem. Allerdings muss man AVR Studio/WinAVR noch ziemlich herum heben, damit diese ansonsten komfortable Kombi überhaupt bereit ist, C++ zu übersetzen. Hier ein Beispiel-Programm für den Nibo:
Code:
#include <avr/interrupt.h>
#include "nibocc/niboconfig.hpp"

#include "nibocc/i2cmaster.hpp"
#include "nibocc/adc.hpp"
#include "nibocc/bot.hpp"
#include "nibocc/delay.hpp"
#include "nibocc/display.hpp"
#include "nibocc/floor.hpp"
#include "nibocc/graphicdisplay.hpp"
#include "nibocc/irco.hpp"
#include "nibocc/leds.hpp"
#include "nibocc/motco.hpp"
#include "nibocc/pwm.hpp"
#include "nibocc/textdisplay.hpp"

#include <stdlib.h> // RAND_MAX 32767
#include <stdint.h>
#include <string.h> // MyString

using namespace nibocc;

// Hilfsfunktionen
float SupplyVoltage(void);


// Hilfsklassen

/*****************
*  Stringklasse  *
******************/

/* 
// nur notwenig für WinAVR bis Mai 2007 bzw. bis GCC 4.1.2
//
// Ersatz für new, new[], delete und delete[] der fehlenden C++-Standard-Bibliothek
void* operator new      (size_t size) { return malloc(size); }
void* operator new[]    (size_t size) { return malloc(size); }
void  operator delete   (void* ptr)   { free(ptr); }
void  operator delete[] (void* ptr)   { free(ptr); }
*/

class MyString
{
  private:
    char * pData_;

  public:
    friend MyString operator+( const MyString &, const MyString & );
    MyString() : pData_( NULL ) {} // inline ctor
    MyString( const char * pText );
	MyString( const MyString & text ); // Copy-Konstruktor
    ~MyString(); // dtor
    const MyString & operator=( const MyString & text );

    bool operator==( const MyString & text ) const;
    char operator[]( int index ) const;
    operator const char * () const; // cast zum C-String
	operator char * () const; // cast zum C-String
    int getLaenge() const;
    void ausgeben() const;
};

MyString operator+( const MyString & leftstring, const MyString & rightstring );

/******************************************************************/

// ctor mit C-String als Argument
MyString::MyString( const char * pText ) : pData_( NULL )
{
  if( pText )
  {
    pData_ = new char[ strlen( pText ) + 1 ];
    strcpy( pData_, pText );
  }
}

// copy-ctor
MyString::MyString( const MyString & text ) : pData_( NULL )
{
  if( text.pData_ )
  {
    pData_ = new char[ strlen( text.pData_ ) + 1 ];
    strcpy( pData_, text.pData_ );
  }
}

// dtor
MyString::~MyString()
{
  delete[] pData_;
}

// ==
bool MyString::operator==( const MyString & text ) const
{
  if( pData_ == NULL || text.pData_ == NULL )
  {
    return ( pData_ == NULL && text.pData_ == NULL );
  }
  return ( strcmp( pData_, text.pData_ ) == 0 );
}

// []
char MyString::operator[]( int i ) const
{
  if( i >= 0 && i < getLaenge() )
  {
    return pData_[i];
  }
  else
  {
    return '\0';
  }
}  

// Länge des Textes ermitteln
int MyString::getLaenge() const
{
  if( pData_ == NULL )
  {
    return 0;
  }
  else
  {
    return strlen( pData_ );
  }
}

// cast zu C-String
MyString::operator const char * () const
{
  return pData_;
}

MyString::operator char * () const
{
  return pData_;
}

// Zuweisungs-Operator
const MyString & MyString::operator=( const MyString & text )
{
  if( this == &text ) // Selbstzuweisung abfangen
  {
    return *this;
  }  
  delete[] pData_;
  if( text.pData_ )
  {
    pData_ = new char[ strlen( text.pData_ ) + 1 ];
    strcpy( pData_, text.pData_ );
  }
  else
  {
    pData_ = NULL;
  }
  return *this;
}

void MyString::ausgeben() const
{
  // TODO
}

/******************************************************************/

MyString operator+( const MyString & leftstring, const MyString & rightstring )
{
  MyString result;
  if( leftstring.pData_ != NULL && rightstring.pData_ != NULL )
  {
    result.pData_ = new char[ strlen( leftstring.pData_ ) +
                              strlen( rightstring.pData_ ) + 1 ];
    strcpy( result.pData_, leftstring.pData_ );
    strcat( result.pData_, rightstring.pData_ );
  }
  else if( rightstring.pData_ != NULL )
  {
    result = rightstring;
  }
  else if( leftstring.pData_ != NULL )
  {
    result = leftstring;
  }
  return result;
}


class RandomStdlib // verwendet rand() aus <stdlib.h>
{ 
private: 
   const uint16_t seed_; 
public: 
   RandomStdlib():seed_(static_cast<uint16_t>(3000*SupplyVoltage())){} 

   int getNum() const 
   { 
     static uint8_t seed_flag=0; 
     if(!seed_flag) 
     { 
       srand(seed_); 
       seed_flag = 1; // true 
     } 
     return rand(); 
   } 
}; 

template<typename T_Generator> 
class Wuerfel 
{ 
private: 
  const uint16_t maxzahl_; 
  const uint16_t maxrandom_; 
  T_Generator zahlengenerator_; // Template-Typ 

public: 
  Wuerfel(uint16_t maxzahl):maxzahl_(maxzahl),maxrandom_(RAND_MAX-(RAND_MAX%maxzahl)) {} 

  uint16_t wuerfelt() 
  { 
    uint16_t r; 
    do{ r = zahlengenerator_.getNum(); } 
      while ( r >= maxrandom_ ); 
    return ( r % maxzahl_ +1 ); 
  } 
}; 


int main()
{
    sei();
    Bot::init();
    Leds::init();
    Pwm::init();
    Display::init();
    Graficdisplay::init(); 
 
    Leds::set_displaylight(1000);

    Graficdisplay::move(0,10);
	Graficdisplay::print_text("Nibo Lichtorgel", 0);
    Graficdisplay::move(0,20);
	Graficdisplay::print_text("mit Zufallsgenerator", 0);
    Graficdisplay::move(0,40);
	Graficdisplay::print_text("LED", 0);
    Graficdisplay::move(40,40);
	Graficdisplay::print_text("Color", 0);

	MyString str, str1, str2;
	str1 ="AVR-Programm mit";
	str2 =" C++!";
	str = str1 + str2;

	Graficdisplay::move(0,54);
	Graficdisplay::print_text( (char *) str, 0);
	    
	Wuerfel<RandomStdlib> w(6); // 1 ... 6
	Wuerfel<RandomStdlib> c(3); // 1 ... 3
	
	uint8_t wurf, color;	
	char text[2];
	
	while(1)
    {
	    static uint16_t pause = 1200;
		pause -=50;
		if(pause<50) pause = 50; 

		wurf  = w.wuerfelt()-1; 
		color = c.wuerfelt();

		itoa(wurf,text,10);
    	Graficdisplay::move(23,40);
		Graficdisplay::print_text(text, 0);

		itoa(color,text,10);
    	Graficdisplay::move(75,40);
		Graficdisplay::print_text(text, 0);

		Leds::set_status(color,wurf);
	    Leds::set_headlights(170*(wurf+1)); // 170...1020
		
		
		Delay::delay(pause); 

		for(int i=0; i<6; ++i)
			Leds::set_status(LEDS_OFF,i);
	}

  while(1);
  return 0;
}

// Hilfsfunktionen

float SupplyVoltage(void)
{
   bot_update();      
   return(0.0166 * bot_supply - 1.19);
}
Zeige bitte mal eines für den ASURO.