D Programmierung

Helium

typedef std::map<MyKey, MyValue*> M; 
for_each( myMap.begin(), myMap.end(), cout << bind( &MyValue::getMember, 
                                               bind( &M::value_type::second, _1 ) ) );

Du hast recht. Das ist ja gleich viel übersichtlicher, als jede gewöhnliche for each Schleife in anderen Sprachen. Einfach genial, vorallem, wenn man mal etwas mehr mit den Werten machen will.

Ben04

Eric Nieblers foreach Makro sieht ja viel versprechend aus. Wenn jetzt noch jemand das Problem mit

BOOST_FOR_EACH(pair<int, char>&p, my_map){

}

lösst bin ich zufrieden.

Denn Artikel sollte sich jeder mal durch lesen. Schon erstaunlich wie man eine const& und einen ?: Zweck entfremden kann.

daHa

gibts ausser diesem killerargument

Klar, es passt in eine Zeile, aber es sieht halt trotzdem nicht geil aus.

noch andere argumente warum ein foreach wie in anderen sprachen implementiert so notwendig, toll oder sonstiges ist?
wie zb das der compiler einen besseren code generiert?

tipparbeit sparen die nicht mal 0,0000000001% der projektzeit ausmacht wuerd ich auch nicht so als killerargument ansehn.

Für dich ist gar nichts ein Argument. Ich kann auch gleich zu einer Wand reden. Ich fang jetzt gar nicht an zu erklären, warum es gar nicht um die reine Tipparbeit geht.

Ben04 schrieb:

Eric Nieblers foreach Makro sieht ja viel versprechend aus. Wenn jetzt noch jemand das Problem mit
BOOST_FOR_EACH(pair<int, char>&p, my_map){
  
}
lösst bin ich zufrieden.

Denn Artikel sollte sich jeder mal durch lesen. Schon erstaunlich wie man eine const& und einen ?: Zweck entfremden kann.

Das sieht ja schon echt nicht schlecht aus. Nen anderen Namen vielleicht noch (trivial) und man kann es fast benutzen. Den Nachteil, dass mögliche Fehlermeldungen auf Code verweisen, den der Programmierer nicht sieht, kriegt man eh nicht los. Das Ding seh ich mir heute Abend mal an.

daHa

setzt eigenlich eine/jede foreach sprachimplementation voraus das die container die mit foreach funktionieren ein gemeinsames interface besitzen?

daHa schrieb:

setzt eigenlich eine/jede foreach sprachimplementation voraus das die container die mit foreach funktionieren ein gemeinsames interface besitzen?

Ne, das ist nur bei Sprachen so die kein festes Typsystem haben und eh alles ein Object ist.

setzt eigenlich eine/jede foreach sprachimplementation voraus das die container die mit foreach funktionieren ein gemeinsames interface besitzen?

Ich kann jetzt nur für C# sprechen: Jein.

In C# gibt es 2 Möglichkeiten eine Collection "enumerable" zu machen.
1. Das Interface IEnumerable implementieren
2. Einfach nur die Methode GetEnumerator zur Verüfung stellen, also IEnumerable "quasi-implementieren"

uberfrickler schrieb:

2. Einfach nur die Methode GetEnumerator zur Verüfung stellen, also IEnumerable "quasi-implementieren"

Hmmmm also für C# stimmt das nicht. Folgender Code compiliert nicht:

using System.Collections;
using System.Collections.Generic;

namespace Test {
	static class Program {
		private static void Main() {
			Test<int> test = null;

			foreach( int i in test ) {
			}
		}

		private class Test<T> {
			public IEnumerator<T> GetEnumerator() {
				return null;
			}

			IEnumerator IEnumerable.GetEnumerator() {
				return null;
			}
		}
	}
}

Mit ": IEnumerable<T>" allerdings schon. In C# musst du dieses Interface wirklich ausdrücklich implementieren, so dass deine Collection diesen Typ auch hat.

Für andere Sprachen muss das allerdings keine zwingende Voraussetzung sein. Der Compiler könnte einfach ausprobieren, ob es passende begin() und end() gibt und entsprechend meckern. In C++ funktionieren die Templates und Makros auch nach diesem Prinzip. Die Schnittstelle muss halt vorhanden sein, sonst compiliert der Code nicht. In Sprachen, die ein Sprachkonstrukt für Schnittstellen haben, wird dieses dann eher vorausgesetzt.

Mit ": IEnumerable<T>" allerdings schon. In C# musst du dieses Interface wirklich ausdrücklich implementieren, so dass deine Collection diesen Typ auch hat.

Das liegt aber auch nur daran, weil du in deinem Beispiel versuchst ein Interface explizit zu implementieren. Versuch mal folgendes:

using System.Collections;
using System.Collections.Generic;

namespace Test { 
    static class Program { 
        private static void Main() { 
            Test<int> test = null; 

            foreach( int i in test ) { 
            } 
        } 

        private class Test<T> { 
            public IEnumerator<T> GetEnumerator() { 
                return null; 
            } 
        } 
    } 
}

Ansonsten sieh dir mal die C# Language Specification an, hab jetzt leider keinen offiziellen Link, aber folgendes sollte es auch tun:
http://www.jaggersoft.com/csharp_standard/15.8.4.htm (Paragraph 4)

Ok, ich bin fasziniert. Das wusste ich auch noch nicht. Das ich das zweite GetEnumerator explizit mache, musste allerdings sein, denn IEnumerable<T> : IEnumerable und man kann nicht zwei verschiede GetEnumerator() haben. Es ist mir allerdings gelungen, das nicht-generische IEnumerable nach deiner Methode zu "implementieren". Implementieren ist natürlich der falsche Begriff, weil das Interface trotzdem nicht implementiert ist (beispielsweise schlägt ein cast danach fehl). Aber für das foreach reicht es offenbar, wann immer man nach der "alten" Methode eine nicht-generische Collection möchte. Danke, wieder was gelernt.

Das Forum ist jetzt unter http://www.d-language.com verfügbar!
Das erste D Video Tutorial "Erste Schritte unter Windows Teil 1" ist auch draussen: http://www.forum.d-language.com/forum/viewtopic.php?t=3
Ja! Ich bin Bayer!

<ronny> mitsuhiko: lol - das ist volkard - der ist in c++ produktiver als der durchschnittliche D programmierer