[Spiel] Findet die Fehler ...

[Gast]

otze schrieb:

ich lös mal auf:

return Helper<T>::function<U>(t);

das ist der Fehler. richtig ist es so:

return Helper<T>::template function<U>(t);

Das Problem ist, dass man nach dem zugriff auf einen templatetyp angeben muss, wenn danach ein weiteres template folgt, denn sonst wird das "<" pauschal als operator< interpretiert.

Ahh gut zu wissen.

otze schrieb:

Das gilt übrigens nicht nur für den operator:: sondern auch für die anderen zugriffsoperatoren, also "." und "->". Einige nichtstandardconforme Compiler spucken hier übrigens keinen Fehler aus, da sie das "template" nicht unbedingt benötigen.

VC++ EE

[Gast]

Das wollte ich ja auch noch auflösen

1.)

(sizeof(stylo) == sizeof(long)

sizeof(Styler) sollte es heißen, oder man macht stylo static. Das ganze drumherum, wie die Templates und Empty Base Optimization sollte natürlich nur Ablenken.

2.)

virtual ~Interface() = 0;

Da denken vllt einige, dass dies korrekt sei, doch einen abstrakten Destruktor sollte man auch Implementieren, da die abgeleiteten Klassen ja den Destruktor der Basisklasse aufrufen müssen.

//Wessen Compiler es mitmacht so:
virtual ~Interface() = 0 { };
//Besser
virtual ~Interface() = 0;
//...
Interface::~Interface() { }

3.)

virtual Typ whoAmI(Typ i = BaseTyp)
virtual Typ whoAmI(Typ i = MyClassTyp)
//...
Base base,*pbase = &base;
cout << pbase->whoAmI() << endl;

MyClass my;
pbase = &my;

cout << pbase->whoAmI() << endl;

Ergibt zweimal 0 also BaseTyp. Das kommt daher, dass Defaultargumente statisch gebunden sind und virtuelle Funktion natürlich dynamisch.
Und da der statische Typ von pbase Base* ist wird zweimal BaseTyp zurückgegeben.

[Gast]

Lust auf mehr kurze Knackige ?

[pumuckl]

ja bitte

[hustbaer]

Ich finde compile-time Fehler viel uninteressanter als andere Fehler. Schliesslich ist es leicht zu wissen dass etwas nicht passt wenn einem der Compiler nen Fehler vorn Latz knallt.

Ich würde also vorschlagen Code zu posten der fehlerfrei compiliert aber sicher nicht das tut was beabsichtigt war. Einfaches Beispiel:

#include <string>

class MyException
{
public:
	MyException() {}
	MyException(std::string const& str) : m_str(str) {}
	MyException(MyException const& other)
	try :
		m_str(other.m_str)
	{}
	catch (...)
	{}

private:
    std::string m_str;
};

3 einfache Fragen:

1. Was wollte der Programmierer hier erreichen?
2. Warum geht es nicht und was passiert stattdessen?
3. Wie lässt es sich fixen?

[Gast]

Kann leider momentan keine posten, da ich mein Netzteil vergessen habe und nun sparsam mit dem Akku umgehen, bis mein Netzteil wieder da ist

Aber für die erste Frage von hustbaer reicht es dennoch

hustbaer schrieb:

1. Was wollte der Programmierer hier erreichen?

Er wollte verhindern, das bei einer geflogenen Exception vom Typ MyException beim Kopieren des throw-Arguments keine weitere Exception rausfliegt.

right ?

[Heinzelotto]

1. er wollte erreichen, dass eine exception in der objektinitialisierungsliste gecatcht wird (aus dem vom vorposter genannten grund).
2. die exception wird so oder so weitergeschmissen, da nicht garantiert werden kann, dass das Objekt in validem Zustand ist.
3. z.B. das ganze in den Body des Konstruktors verlagern.

[Ben04]

Alternativ kann man auch ein C-String mit fester Länge benutzen und so den Code ausnahmefrei bekommen.

Folgender Code produziert 1 Fehler bei der Übersetzung. Bitte keinen Compiler benutzen, da die Fehlermeldungen in der Regel recht eindeutig sein sollte.

#include <vector>
#include <algorithm>
using namespace std;

namespace foo{
	struct Data{
		int a;
	};

	bool operator<(const Data&a, const Data&b){
		return a.a < b.a;
	}

	void swap(Data&a, Data&b){
		if(&a != &b){
			a.a ^= b.a;
			b.a ^= a.a;
			a.a ^= b.a;
		}
	}
}

class MyContainer:private vector<foo::Data>{
	typedef vector<foo::Data> super;
public:
	using super::iterator;
	using super::const_iterator;
	using super::begin;
	using super::end;
	using super::size;
	using super::empty;
};

class MySuperContainer:public MyContainer{
public:
	void fast_sort(){
		if(size() == 2){
			iterator i = begin(), j = i;
			++j;
			if(*j < *i)
				swap(*j, *i);
		}else
			sort(begin(), end());
	}
};

[Heinzelotto]

hmm, das einzige, was mir aufgefallen ist, ist, dass swap eigentlich im namespace foo ist, oder?
naja, ich werds jetzt mal durchn compiler laufen lassen

Spoiler:

edit: es lässt sich tatsächlich durch Ändern zu foo::swap(... lösen.
was ich allerdings ursprünglich nicht gewusst (nur etwas geahnt) hatte, ist, dass vector auch eine methode swap besitzt (*referenz-nachguck*). Aber da diese Methode dazu da ist, die Inhalte eines vectors mit denen eines anderen zu tauschen, ist die hier wohl nicht sondelich hilfreich.

[Ben04]

Heinzelotto schrieb:

hmm, das einzige, was mir aufgefallen ist, ist, dass swap eigentlich im namespace foo ist, oder?

Dank Koenig-Lookup dürfen solche Helferfunktionen auch im gleichen Namesraum wie der Typ selbst sein.

[Heinzelotto]

Ben04 schrieb:

Heinzelotto schrieb:

hmm, das einzige, was mir aufgefallen ist, ist, dass swap eigentlich im namespace foo ist, oder?

Dank Koenig-Lookup dürfen solche Helferfunktionen auch im gleichen Namesraum wie der Typ selbst sein.

Spoiler:

ok, dann ergibt das Sinn. Der Compiler denkt, dass der User die methode vector::swap aufrufen will, die ja aber durch die private vererbung unzugänglich geworden ist (und die sowieso nicht von den übergabeparametern her passt). Durch absolute Qualifizierung der anderen Methode lässt sich das Problem aber umgehen.

[camper]

Wie wird es geheilt?

class MySuperContainer:public MyContainer{
public:
    void fast_sort(){
        using ::std::swap; // <---
        if(size() == 2){
            iterator i = begin(), j = i;
            ++j;
            if(*j < *i)
                swap(*j, *i);
        }else
            sort(begin(), end());
    }
};

[Phoemuex]

#include <iostream>
#include <vector>
#include <string>

struct bar
{
   int id;
   std::string name;
};

bar* find(std::vector<bar*> const &vec, std::string const &theName)
{
   for(std::vector<bar*>::const_iterator it = vec.begin(); it != vec.end(); ++it)
   {
      if((*it)->name == theName)
      {
          return *it;
      }
   }
   return 0;
}

bool exists(std::vector<bar*> const &vec, std::string const &theName)
{
   return find != 0;
}

void print(std::vector<bar*> const &vec)
{
   for(std::vector<bar*>::const_iterator it = vec.begin(); it != vec.end(); ++it)
   {
      std::cout << (*it)->name << ", " << (*it)->id << std::endl;
   }
}

Der Code kompiliert, tut aber nicht das, was er eigentlich soll. So wie es hier ist, dürfte es reicht einfach zu finden sein...

Felix

[camper]

Klassiker.

[Heinzelotto]

die adresse von find, die ja != 0 ist, ergibt immer "wahr"

[Gast]

Schnell was kurzes:

//dat1.cpp
extern int S;
extern int var = 112;

int main()
{
    int zahl = S * var;
}

//dat2.cpp
int var;
const int S = 10;

Beide werden natürlich gegeneinander gelinkt.

[SchlussMitKindergarten]

Was wollte der Programmierer und was ist falsch?

#include <iostream>

class friends{
public:
	friends(int i):n(i){}
	bool operator^(friends const & o){return n<o.n;}
	void operator~(){n++;}
	bool operator%(friends mo){	
		int s=0;int i = 1;
		for(;i < mo.n;i++){
			switch(mo.n%i){
				default: continue;
				case 1: s+=i;
			}
		}
		return s==n;
	}
	friend std::ostream& operator << (std::ostream& os, friends const& s){
		return os<<s.n;
	}

private:
	int n;
};

int main(int argc, char *argv[])
{
	for(friends i = 1; i^20000; ~i){
		friends j = 1;
		switch(j^i){
			for(; j^i; ~j){
				default:
				if(!(j^i && i^j) && i%j && j%i) std::cout << j << "  " << i << std::endl;
				continue;
			}
			case 0:
				break;
		}
	}
}

[Gast]

KasF schrieb:

//dat1.cpp
extern int S;
extern int var = 112;

int main()
{
    int zahl = S * var;
}

//dat2.cpp
int var;
const int S = 10;

1. Fehler: Mehrfache Definition von var, da die eine direkte initialisierung bei extern auch gleichzeitig eine Definition ist, wohingegen ohne = x nur eine Deklaration.

2. Fehler: Globale const Variablen sind wie globale static's, dh lokal innerhalb der Übersetzungseinheit. Deswegen führt ein extern int S zu einem 'undefined reference'. Abhilfe: Noch ein extern vor der Definition.

Nun habe ich wieder Akku-Power und heute Abend kommen dann wieder schöne Codes.

[Gast]

class LittleDataClass 
{
   friend class MyClass;

   private:
            LittleDataClass() { };
};

class MyClass 
{
    private:
             LittleDataClass dclass;
};

1.) Was wollte der Programmierer hier erreichen ?
2.) Hätte er es besser machen können ?

typedef unsigned int uInt;

class LetterCounter
{
	virtual uInt getCounts(char c) = 0;
};

class LetterCounter1 : public LetterCounter
{
    private:
             string str;
    public:
             explicit LetterCounter1(const string& str) : str(str) { }

             uInt getCounts(char c) 
             {
                 uInt helper = 0;
                 for(size_t i = 0; i < str.size(); ++i)
                                 if( c == str[i] ) ++helper;

                 return helper;
             }

};

class LetterCounter2 : public LetterCounter
{
    private:
             map<char, uInt> county;	
    public:
             explicit LetterCounter2(const string& str) 
             {
                for(size_t i = 0; i < str.size(); ++i) 
                        ++county[str[i]];
             }

             uInt getCounts(char c) 
             {
                 return county[c];
             }

};

void showAllCounts(const LetterCounter& lc, const string& str)
{
	for(size_t i = 0; i < str.size(); ++i) 
	{
		cout << "Count of ." << str[i] << ". in <" << str << ">: " << lc.getCounts(str[i]) << endl; 
	}
}

int main()
{
	string str1 = "das ist doch alles voll easy";
	string str2 = "kommt denn nichtmal was schwieriges";

	LetterCounter1 lc1(str1);
	LetterCounter2 lc2(str2);

	showAllCounts(lc1, str2);	
	cout << "Count of .a. in str1: " << lc2.getCounts('a') << endl; 

}

1.) Wo ist hier das Problem ?
2.) Hätte der Programmierer getCounts() nicht besser mit const versehen sollen?

[pumuckl]

1. Vermutlich soll LittleDataClass nur von MyClass instantiiert werden dürfen 2) eine sinnvollere Lösung als die Friend-Geschichte wäre vermutlich, LittleDataClass zur privaten Unterklasse von MyClass zu machen.

3)Das Problem ist, dass der output von showAllCounts(lc1, str2); behauptet, die Anzahl der jeweiligen Zeichen in str2 auszugeben - tatsächlich wird getcounts aber die Anzahl der Zeichen des Strings ausgeben, mit dem der Counter initalisiert wurde, also str1.

4. getCounts hätte mit const versehen werden sollen, damit der Aufruf in showAllCounts legal ist und überhaupt kompiliert. Allerdings hätte dann LetterCounter2::getCounts mit konstanten map-methoden umgeschrieben werden müssen:

uInt getCounts(char c) const
{
  map<char, uInt>::const_iterator pos = county.find(c);
  if (pos == conty.end() ) return 0;
  else return pos->second;
}

einen const_cast auf die map loszulassen oder sie als mutable zu deklarieren wäre unschön bzw. ein Designfehler.

5. Andererseits könnte man LetterCounter1::getCounts vereinfachen:

uInt getCounts(char c) const
{
  return std::count(str.begin(), str.end(), c);
}

Die Aufgaben sind was nettes zum Frühstück