Ich habe ein Programm geschrieben (zur Übung), welches es ermöglicht in einer Klasse ein bestimmtes Buch zu speichern.
Die beiden Angaben, welche gemacht werden sind ISBN Nummer und Preis.
Also eigentlich eine recht einfach Sache.
Es gibt zwei Klassen.
Die erste kann per Funktion net_price den Buchpreis zurückgeben.
Die zweite Klasse erbt von der ersten und unterstützt in der Funktion net_price noch ein bestimmtes Rabattmodell.

Um einen Warenkorb zu realisieren, habe ich eine weitere Klasse Basket geschrieben, welche ein Set aus Elementen meiner beiden Klassen enthält.
Damit im Set abgeleitete und Basisklasse gespeichert werden kann habe ich zur besseren Handhabung für den Benutzer eine Handleklasse "Sales_item" entwickelt.

Allerdings habe ich ein Problem, als ich das ganze Programm nun in mehrere Dateien unterteilt habe (Headerdatei etc).
Seit ich das gemacht habe gibt der Compiler eine bescheuerte Fehlermeldung, welche ich einfach nicht wegbekomme- hatte eig nicht im Forum nachfragen wollen, weil mein Quelltext nun eig zu lang ist für nen Forenbeitrag aber ich weiß mir da einfach nicht mehr zu helfen.
Aber man muss auch denke nicht durch den gesammten Quelltext durchblicken um den Fehler zu finden.
Fehlermeldung vom Linker:

[Linker error] undefined reference to `compare(Sales_item const&, Sales_item const&)'

Meine Main.cpp:

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <stdexcept>
#include "Bulk_item.h"
using std::string;
using std::vector;
using std::set;
using std::cout;
using std::cin;
using std::map;
using std::cerr;
using std::endl;
using std::fstream;
using std::ifstream;
using std::ios;   
int main()
{
   Item_base ib1("Stephen King - Shining", 10);
   Sales_item si1(ib1);
   Item_base ib2("Harry Potter - Und der Stein der Weisen", 40);   
   Sales_item si2(ib2);
   Item_base ib3("Harry Potter - Und die Kammer des Schreckens", 40);      
   Sales_item si3(ib3);      
   Item_base ib4("Harry Potter - Und der gefangene von Askaban", 40);
   Sales_item si4(ib4);  
   Item_base ib5("Harry Potter - Und der Feuerkelch", 40);    
   Sales_item si5(ib5);      
   Item_base ib6("Harry Potter - Und der Orden des Phoenix", 40);
   Sales_item si6(ib6);               
   Item_base ib7("Harry Potter - Und der Halbblutprinz", 40);
   Sales_item si7(ib7);               
   Item_base ib8("Harry Potter - Und die Heiligtümer des Todes", 40);   
   Sales_item si8(ib8);                
   Bulk_item bi1("Stephen King - Carrie", 5, 3);     
   Sales_item si9(bi1);                                                       //Bei 3 Büchern gibts 20% Rabatt
   Bulk_item bi2("Stephen King - Carrie", 5, 3);
   Sales_item si10(bi2); 
   Bulk_item bi3("Stephen King - Carrie", 5, 3);
   Sales_item si11(bi3); 
   Bulk_item bi4("Ronald Tolkien - Herr der Ringe Teil 1", 10, 3);
   Sales_item si12(bi4); 
   Bulk_item bi5("Ronald Tolkien - Herr der Ringe Teil 2", 10, 3);
   Sales_item si13(bi5); 

   si13 = si1;

   Basket B;
   B.add_item(si1);
   B.add_item(si2);
   B.add_item(si3);
   B.add_item(si4);         
   B.add_item(si5);
   B.add_item(si6);
   B.add_item(si7);
   B.add_item(si8);
   B.add_item(si9);
   B.add_item(si10);
   B.add_item(si11);
   B.add_item(si12);   
   B.add_item(si13);  
   cout << B.total() << endl;    
   system("Pause > NUL");
}

Die 4 Klassen:

#include <string>
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <stdexcept>

/**********************************************************/
class Item_base
{
   public:
      Item_base(const std::string& book = "", double sales_price = 0.0) : isbn(book), price(sales_price) {   }
      std::string book() const
      {
         return isbn;            
      }
      virtual double net_price(std::size_t n) const
      {
         return n * price;        
      }
      virtual ~Item_base() {   }
      virtual Item_base* clone() const
      {
         return new Item_base(*this);        
      }
   private:
      std::string isbn;
   protected:
      double price;
};
/**********************************************************/
class Bulk_item : public Item_base
{
   public:
      double net_price(std::size_t) const;
      Bulk_item* clone() const
      {
         return new Bulk_item(*this);           
      }
      Bulk_item(const std::string& book, double sales_price, std::size_t qty, double disc_rate = 0.2): //Bekommt Standardmäßig 20%
                Item_base(book, sales_price), min_qty(qty), discount(disc_rate)   {   }
   private:    
      std::size_t min_qty;
      double discount;
};
class Sales_item
{
   public:
      Sales_item(): p(0), use(new std::size_t(1)) {   }
      Sales_item(const Item_base& item):p(item.clone()), use(new std::size_t(1)){    }
      Sales_item(const Sales_item &i): p(i.p), use(i.use)    {   }   
      void decr_use(); 
      ~Sales_item() 
      {
         decr_use();              
      }
      Sales_item& operator=(const Sales_item&);
      const Item_base *operator->() const;
      const Item_base &operator*() const;     
   private:
      Item_base * p;
      std::size_t *use;      
};
//Funktionsdeklarationen:
inline bool compare(const Sales_item &lhs,const Sales_item& rhs)
{
   return lhs->book() < rhs->book();     
}

/**********************************************************/
class Basket
{
   typedef bool(*Comp) (const Sales_item&, const Sales_item&);
   public:
      typedef std::multiset<Sales_item, Comp> set_type;
      typedef set_type::size_type size_type;
      typedef set_type::const_iterator const_iter;
      Basket(): items(compare) {   }                   //items wird hier nicht mit 'compare' initialisiert, sondern bentutz die Funktion 'compare' zum Ordnen seiner Elemente.
      double total() const; 
      void add_item(const Sales_item &item)
      {
         items.insert(item);     
      }    
      size_type size(const Sales_item &i) const
      {
         return items.count(i);          
      }    
   private:
      std::multiset<Sales_item, Comp> items;
};
/**********************************************************/

Funktionsdefinitionen der 4 Klassen:

#include "Bulk_item.h"
//Memberfunktionen von Bulk_item:
double Bulk_item::net_price(size_t cnt) const
{
   if(cnt >= min_qty)
      return cnt * (1-discount) * price;
   else
      return cnt*price;       
}
//Memberfunktionen von Item_base:
const Item_base* Sales_item::operator->() const
{
   if(p) 
   {
      return p;      
   }
   else
   {
      throw std::logic_error("Ungültiges Objekt");    
   }
}
const Item_base& Sales_item::operator*() const
{
   if(p)
   {
      return *p;     
   }      
   else
   {
      throw std::logic_error("Ungültiges Objektm");
   }
}
//Memberfunktionen von Sales_item:
double Basket::total() const
{
   double sum = 0.0;
   for(Basket::const_iter iter = items.begin(); iter != items.end(); iter = items.upper_bound(*iter)) //upper_bound gibt einen Iterator auf das erste 
   {                                                                                          //Element zurück, welches größer als *iter ist.
      sum += (*iter)->net_price(items.count(*iter));
   }       
   return sum;
}
void Sales_item::decr_use()
{
    if(--*use == 0)
    {
       delete p; 
       delete use;          
    }     
}
Sales_item& Sales_item::operator=(const Sales_item &rhs)
{
   ++*rhs.use;
   decr_use();
   p = rhs.p;
   use = rhs.use;
   return *this;            
}

Die Funktion, welche den Vergleichsoperator des Vektors überschreibt, heißt compare und ist von mir als inline gekennzeichnet worden, da sie nur einmal aufgerufen wird.

Ich hoffe der Quelltext überrumpelt keinen und jemand von euch weiß, was ich beim aufteilen der Dateien falsch gemacht habe- steht alles in einer Datei gehts

Tschüss

David

Was sollte ich denn ändern?
Wie ists denn guter Programmierstil?^^

Ich hoffe der Quelltext überrumpelt keinen und jemand von euch weiß, was ich beim aufteilen der Dateien falsch gemacht habe...

1. Inkludiere nur das was du in der konkreten Codeeinheit benötigst (Ebenso sind deine using-Anweisungen auf unnötige Bestandteile)

2. Du hast schon mehrfach gepostet und solltes auch wissen das man die c++ Tags und nicht die Codetags einsetzten sollte (Erhöht ebenso die lesbarkeit ungemein).

3. Dir ist hoffentlich bewusst das Zeiger auf Inlinefunktionen nicht funktionieren können (Inline wird wie der Name schon sagt bei der Benutzung aufgelöst und hat daher keine Ansprungadresse).

4. Auch wenn du es erwähnt hast, ändert es nichts daran das du lieber eine Codeeinheit pro Klasse verwenden solltest. Und die Definitionen sollten auch im Source nicht im Header enthalten sein.

cu André

Allerdings müssten Inlinefunktionen doch im Header definiert werden- müsste doch ne Ausnahme sein.

Also wenn ich 3 klassen und eine Main.cpp habe, müsste ich im Endeffekt 7 Dateien dadraus machen, weil 3 Headerdateien, 3 CPP-Funktsiondefinitionen, 1 Main.cpp

Allerdings müssten Inlinefunktionen doch im Header definiert werden- müsste doch ne Ausnahme sein.

Ja, nur sehe ich dort noch deutlich mehr Methodendefinitionen (Ändert aber nichts daran das von Inlines keine Funktionszeiger angelegt werden können ;p).

cu André

Folgender Quelltext lässt sich ohne Probleme compilieren:

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <stdexcept>
/**********************************************************/
class Item_base
{
   public:
      Item_base(const std::string& book = "", double sales_price = 0.0) : isbn(book), price(sales_price) {   }
      std::string book() const
      {
         return isbn;            
      }
      virtual double net_price(std::size_t n) const
      {
         return n * price;        
      }
      virtual ~Item_base() {   }
      virtual Item_base* clone() const
      {
         return new Item_base(*this);        
      }
   private:
      std::string isbn;
   protected:
      double price;
};
/**********************************************************/
class Bulk_item : public Item_base
{
   public:
      double net_price(std::size_t) const;
      Bulk_item* clone() const
      {
         return new Bulk_item(*this);           
      }
      Bulk_item(const std::string& book, double sales_price, std::size_t qty, double disc_rate = 0.2): //Bekommt Standardmäßig 20%
                Item_base(book, sales_price), min_qty(qty), discount(disc_rate)   {   }
   private:    
      std::size_t min_qty;
      double discount;
};
double Bulk_item::net_price(size_t cnt) const
{
   if(cnt >= min_qty)
      return cnt * (1-discount) * price;
   else
      return cnt*price;       
}
/**********************************************************/
class Sales_item
{
   public:
      Sales_item(): p(0), use(new std::size_t(1)) {   }
      Sales_item(const Item_base& item):p(item.clone()), use(new std::size_t(1)){    }
      Sales_item(const Sales_item &i): p(i.p), use(i.use) 
      {     
         *use++;
      }    
      ~Sales_item() 
      {
         decr_use();              
      }
      Sales_item& operator=(const Sales_item&);
      const Item_base *operator->() const
      {
         if(p) 
         {
            return p;      
         }
         else
         {
            throw std::logic_error("Ungültiges Objekt");    
         }
      }
      const Item_base &operator*() const
      {
         if(p)
         {
            return *p;     
         }      
         else
         {
            throw std::logic_error("Ungültiges Objektm");
         }
      }
   private:
      Item_base * p;
      std::size_t *use;
      void decr_use()
      {
         if(--*use == 0)
         {
            delete p; 
            delete use;          
         }     
      }

};
Sales_item& Sales_item::operator=(const Sales_item &rhs)
{
   ++*rhs.use;
   decr_use();
   p = rhs.p;
   use = rhs.use;
   return *this;            
}

inline bool compare(const Sales_item &lhs, const Sales_item &rhs)
{
   return lhs->book() < rhs->book();       
}

/**********************************************************/
class Basket
{
   typedef bool(*Comp) (const Sales_item&, const Sales_item&);
   public:
      typedef std::multiset<Sales_item, Comp> set_type;
      typedef set_type::size_type size_type;
      typedef set_type::const_iterator const_iter;
      Basket(): items(compare) {   }                   //items wird hier nicht mit 'compare' initialisiert, sondern bentutz die Funktion 'compare' zum Ordnen seiner Elemente.
      void add_item(const Sales_item &item)
      {
         items.insert(item);     
      }    
      size_type size(const Sales_item &i) const
      {
         return items.count(i);          
      }
      double total() const
      {
         double sum = 0.0;
         for(const_iter iter = items.begin(); iter != items.end(); iter = items.upper_bound(*iter)) //upper_bound gibt einen Iterator auf das erste 
         {                                                                                          //Element zurück, welches größer als *iter ist.
            sum += (*iter)->net_price(items.count(*iter));
         }       
         return sum;
      }
   private:
      std::multiset<Sales_item, Comp> items;

};
/**********************************************************/
using std::string;
using std::vector;
using std::set;
using std::cout;
using std::cin;
using std::map;
using std::cerr;
using std::endl;
using std::fstream;
using std::ifstream;
using std::ios;   
int main()
{
   Item_base ib1("Stephen King - Shining", 10);
   Sales_item si1(ib1);
   Item_base ib2("Harry Potter - Und der Stein der Weisen", 40);   
   Sales_item si2(ib2);
   Item_base ib3("Harry Potter - Und die Kammer des Schreckens", 40);      
   Sales_item si3(ib3);      
   Item_base ib4("Harry Potter - Und der gefangene von Askaban", 40);
   Sales_item si4(ib4);  
   Item_base ib5("Harry Potter - Und der Feuerkelch", 40);    
   Sales_item si5(ib5);      
   Item_base ib6("Harry Potter - Und der Orden des Phoenix", 40);
   Sales_item si6(ib6);               
   Item_base ib7("Harry Potter - Und der Halbblutprinz", 40);
   Sales_item si7(ib7);               
   Item_base ib8("Harry Potter - Und die Heiligtümer des Todes", 40);   
   Sales_item si8(ib8);                
   Bulk_item bi1("Stephen King - Carrie", 5, 3);     
   Sales_item si9(bi1);                                                       //Bei 3 Büchern gibts 20% Rabatt
   Bulk_item bi2("Stephen King - Carrie", 5, 3);
   Sales_item si10(bi2); 
   Bulk_item bi3("Stephen King - Carrie", 5, 3);
   Sales_item si11(bi3); 
   Bulk_item bi4("Ronald Tolkien - Herr der Ringe Teil 1", 10, 3);
   Sales_item si12(bi4); 
   Bulk_item bi5("Ronald Tolkien - Herr der Ringe Teil 2", 10, 3);
   Sales_item si13(bi5); 

   si13 = si1;

   Basket B;
   B.add_item(si1);
   B.add_item(si2);
   B.add_item(si3);
   B.add_item(si4);         
   B.add_item(si5);
   B.add_item(si6);
   B.add_item(si7);
   B.add_item(si8);
   B.add_item(si9);
   B.add_item(si10);
   B.add_item(si11);
   B.add_item(si12);   
   B.add_item(si13);  
   cout << B.total() << endl;    
   system("Pause > NUL");
}

3. Dir ist hoffentlich bewusst das Zeiger auf Inlinefunktionen nicht funktionieren können (Inline wird wie der Name schon sagt bei der Benutzung aufgelöst und hat daher keine Ansprungadresse).

Unfug.

asc schrieb:

3. Dir ist hoffentlich bewusst das Zeiger auf Inlinefunktionen nicht funktionieren können (Inline wird wie der Name schon sagt bei der Benutzung aufgelöst und hat daher keine Ansprungadresse).

Unfug.

Okay, habe nachgeschaut, hast recht. In dem Fall ist das inline aber unnütz, da es eh "entfernt" wird.

If you do this, the compiler will place a normal subroutine version of the inline's implementation in an object file and give you the address of that, so the function pointer does not really point to an inline function at all.

cu André

Okay, habe nachgeschaut, hast recht. In dem Fall ist das inline aber unnütz, da es eh "entfernt" wird.

Nicht wirklich. Wenn die inline Funktion auch ohne den Funktionspointer verwendet wird, macht sie schon Sinn. Denn es passiert dann beides: inlining und der Aufbau der eigentlichen Funktion.

int main()
{
    vector<Sales_item> items;
    items.push_back( Item_base( "Stephen King - Shining", 10 ) );
    items.push_back( Item_base( "Harry Potter - Und der Stein der Weisen", 40 ) );
    items.push_back( Item_base( "Harry Potter - Und die Kammer des Schreckens", 40 ) );
    ...
    items.push_back( Bulk_item( "Stephen King - Carrie", 5, 3 ) );
    ...

    Basket B;
    for ( vector<Sales_item>::const_iterator itemIter=items.begin(); itemIter!=items.end(); itemIter++ )
        B.add_item( *itemIter );

    ...
}

So ungefähr..

camper schrieb:

asc schrieb:

3. Dir ist hoffentlich bewusst das Zeiger auf Inlinefunktionen nicht funktionieren können (Inline wird wie der Name schon sagt bei der Benutzung aufgelöst und hat daher keine Ansprungadresse).

Unfug.

Okay, habe nachgeschaut, hast recht. In dem Fall ist das inline aber unnütz, da es eh "entfernt" wird.

If you do this, the compiler will place a normal subroutine version of the inline's implementation in an object file and give you the address of that, so the function pointer does not really point to an inline function at all.

cu André

Es ist trotzdem notwendig, wenn diese Funktion weiterhin im Header definiert werden soll (Alternativen: nicht im Header definieren, Funktion static machen oder in einen unbenannten Namensraum verschieben).