[Sammelthread]Verwirrende Code-Fragmente

[zwergmulch]

OK, ich geb's zu. Aber wie ist nun die Lösung??? [neugierig]*Erklärung haben wollen*[/neugierig] :?:

[jgl]

Ich sage 4 mal 3.14.... *unruhig auf seinem Stuhl sitzend*
NEIN, oder doch nicht....

[Alexander Kornrumpf]

Ich fand ihn hier immer beeindruckend:
[blubb]

Was ich dabei nicht verstehe, warum der präprozessor nicht den underscore zwische F und OO beim Funktionsnamen ersetzt.

EDIT:
Macht man sich normal keine Gedanken drüber: ist -- ein anderes Token ist als - - (letzteres eigentlich zwei Token)? Slightly related: Kompiliert int i=1; ---i; und wenn ja zu was?

[Aramis]

Nagut, die Aufloesung (*duckt sich praeventiv weil er sich nicht ganz an die Regeln gehalten hat*):

Undefined Behaviour.

floats werden bei Uebergabe an eine variable Argumentliste nach double konvertiert. Das ist auch der Grund weshalb printf's ‘%f’ fuer beide, float und double, funktioniert. In der Praxis ist das Ergebnis gemaess IEEE 754 durchaus vorhersagbar.

[Psycho]

Ich fand ihn hier immer beeindruckend:
[blubb]

Was ich dabei nicht verstehe, warum der präprozessor nicht den underscore zwische F und OO beim Funktionsnamen ersetzt.

http://msdn.microsoft.com/en-us/library ... S.80).aspx
The identifier is replaced only when it forms a token. (See C++ Tokens in the C++ Language Reference.) For instance, identifier is not replaced if it appears in a comment, within a string, or as part of a longer identifier.

Edit: Oh zu langsam.

Slightly related: Kompiliert int i=1; ---i; und wenn ja zu was?

http://msdn.microsoft.com/en-us/library ... S.80).aspx
The parser separates tokens from the input stream by creating the longest token possible using the input characters in a left-to-right scan. Consider this code fragment:

a = i+++j;
The programmer who wrote the code might have intended either of these two statements:

a = i + (++j)

a = (i++) + j
Because the parser creates the longest token possible from the input stream, it chooses the second interpretation, making the tokens i++, +, and j.

[jgl]

/Toller Thread :) [/i]

*Gesicht zum Fragezeichen geballt*

Wieso lässt sich das vorhersagen?
Wieso kommt da 2.0000 heraus?

[Aramis]

Naja, weil du das Bitmuster des double's, den der Aufrufer auf den Stack schiebt, halbwegs vorhersagen kannst. Und dann schneidet die Funktion ja quasi die untere Haelfte davon weg und interpretiert sie als float :-)

[jgl]

Ahh, okay!
Danke für die Erklärung :)

[Lord Delvin]

Macht das jeder Compiler? Kann mich an so Probleme nicht erinnern, obwohl ich mal relativ begeistert varargs verwendet hab. Is aber mit variablen Templateargumenten total nutzlos geworden.

[Aramis]

Naja, der C++11–Draft spezifiziert das Verhalten, C99 auch. Leider etwas verklausuliert:

When there is no parameter for a given argument, the argument is passed in such a way that the receiving
function can obtain the value of the argument by invoking va_arg

…

After these conversions,if the argument does not have arithmetic, enumeration, pointer, pointer to member, or class type, the program is ill-formed. Passing a potentially-evaluated argument of class type (Clause 9) with a non-trivial copy constructor or a non-trivial destructor with no corresponding parameter is conditionally-supported, with implementation-defined semantics. If the argument has integral or enumeration type that is subject to the integral promotions (4.5), or a floating point type that is subject to the floating point promotion (4.6), the value of the argument is converted to the promoted type before the call. These promotions are referred to as the default argument promotions

So, naechstes Raetsel. Legt los :-)

[zwergmulch]

Dann will ich mal das nächste anfangen.

Das Ganze ist in Scala, gefunden habe ich das bei

Bitte nicht gucken - nur eine Quellen-AngabeIT-Republik/JAXENTER

Wollen wir mal anfangen! Das ist eine Art "Bibliothek", die die nachfolgende Applikation nutzt:

Code: Alles auswählen

import scala.actors._

trait StoppableActor extends Actor {
  private var handler: Any => Any = {null}

  def act {
    while (true) {
      receive {
        case "STOP" => println ("stop"); exit (null)
        case o => handler (o)
      }
    }
  }
  
  def handle (f: Any => Any) = handler = f
}

object StoppableActor {
  def run (f: Any => Any) = {
    new StoppableActor {
      handle (f)
    }.start
  }
}

Nun die wirkliche Applikation:

Code: Alles auswählen

import StoppableActor._
object Main extends Application {
val stage1 = run {
  case i: Int if i > 0 => stage2 ! i
  case _ => null
}

val stage2 = run { 
  case i: Int => 
    stage3 ! "Die Zahl " + i
    stage3 ! i
}
  
val stage3 = run { 
  case i: Int    => println ("Int:    " + i)
  case o: String => println ("String: " + o)
}
  
stage1 ! 5
stage1 ! -1
  
stage1 ! "STOP"
stage2 ! "STOP"
stage3 ! "STOP"
}

Viel Glück beim Raten!

[Hanno]

String: Die Zahl 5
Int: 5
stop
stop
stop

[zwergmulch]

Stimmt. Der nächste, bitte! :D

[Zudomon]

Huhu,
jetzt von mir, ein Programm, welches ich damals für Microcontroller-Programmierung angefertigt habe...
vielleicht errät ja jemand, wofür das da ist oder wie es funktioniert... dafür müsste es aber eventuell erstmal enthedert werden:

Code: Alles auswählen

#include <io6811.h>
#include <boardio.h>
#include <int6811.h>
unsigned char k[12],x
=0,a[12]={0,64,0,121,36,
48,25,18,2,120,0,16};unsigned
short z=0;interrupt void TOC5_interrupt
(void){TFLG1=8;TOC5=TCNT+2500;PIA1BDR=(x=++x
%12)%4;PIA1ADR=a[z>>(x%4)*4&15];if(!k[x]&&k[x]
=!(PIA1BDR&(32<<x%3)))z=(z<<4)*(x!=9)|(z>>4)*(x
==9)|x*(x!=9);}voidmain (void){PIA1ACR=PIA1BCR=
0;PIA1ADR=127;PIA1BDR=3;PIA1ACR=PIA1BCR=PIA_DR;
TMSK1=8;enable_interrupt();while(1);}

Viel Spass beim raten! :D

[zwergmulch]

Ok, wird wohl so schnell keiner mehr erraten, also: "Auflösung bitte!" ;)

Ich fange aber schon mal mit dem nächsten an:
Ist in Java, und weil das sonst zu leicht wäre, habe ich mal die Namen "verschlüsselt":

Code: Alles auswählen

public class Foo<T>{
public boolean m1() { return true; }
public T m2(){ return null; }
public Foo<T> m3 () { return null; }
public Foo<T> m4 (final T bar) {
 final Foo<T> v1 = this;
 return new Foo<T> (){
 public boolean m1 () { return false; }
 public T m2 () { return bar; }
 public Foo<T> m3 () { return v1;}
};
}
}

Na, was implementiert das :?:
Und Zusatzfrage: Bitte eine möglichst gleiche Implementierung in C++ (meiner Meinung nach nicht möglich). :twisted:

[CodingCat]

Eine extrem hässliche verkettete Liste mit NULL-Element am Anfang / Ende?!? Ich wüsste jedoch nicht, wieso ich sowas in C++ implementieren sollte. Ob es in Java sinnvoll ist, hängt wohl von dem Kontext ab, aus dem das herausgerissen wurde. ;-)

[zwergmulch]

So kann man es auch nennen, ich würde es aber eher "eine funktionale Implementierung eines Stacks" nennen. :lol: 8-)
Sicher nicht unbedingt sinnvoll, aber wohl eine der kürzesten/die kürzeste Implementierung eines Stacks. :D

Edit: Hier noch mal ordentlich:

Code: Alles auswählen

public class Stack<T>{
 public boolean isEmpty () { return true; }
 public T top () { return null; }
 public Stack<T> pop () { return null; }
 public Stack<T> push (final T elem) {
   final Stack<T> old = this;
   return new Stack<T> () {
    @Override public boolean isEmpty () { return false; }
    @Override public T top () { return elem; }
    @Override public Stack<T> pop () { return old; }
  };
 }
}

[CodingCat]

Wieso gibst du eigentlich immer false zurück?

[zwergmulch]

Ups! Das war ein Fehler. :( Siehe ordentliche Implementierung im neuen Post. Ist jetzt korrigiert.

[Aramis]

Das faellt dann wohl in die Kategorie Closure-Missbrauch und sollte eigentlich mit dem Tode bestraft werden :-)

[Zudomon]

Ok, wird wohl so schnell keiner mehr erraten, also: "Auflösung bitte!"

Schade, dass es keiner rausbekommen hat.
Damit wurde ein Ziffernblockmodul angesprochen. Es hatte 3 Spalten und 4 Zeilen... in der untersten war links und rechts eine Funktionstaste, in der Mitte die 0.
Es gab dazu noch ein Ausgabefeld für 4 Ziffern. In der Ausgabe sollten die gedrückten Tasten erscheinen. Dabei musste beachtet werden, dass die Tasten prellen. Damit die Taste nur einmal angenommen wird, darf sie während des Prellintervalls nicht nochmal registriert werden. Die eine Funktionstaste sollte ein Backspace realisieren, mit der anderen wurden alle Ziffern gelöscht.

Hier nochmal die enthedderte Version:

Code: Alles auswählen

#include <io6811.h>
#include <boardio.h>
#include <int6811.h>
#define A PIA1ADR
#define B PIA1BDR
                   
unsigned char k[12],x=0,          
              a[12]={0,64,0,121,36,48,25,18,2,120,0,16};
unsigned short z=0;

interrupt void TOC5_interrupt(void) 
{
  TFLG1=8;
  TOC5=TCNT+2500;
  B=(x=++x%12)%4;
  A=a[z>>(x%4)*4&15];
  if(!k[x]&&k[x]=!(B&(32<<x%3)))z=(z<<4)*(x!=9)|(z>>4)*(x==9)|x*(x!=9);
}

void main (void) 
{
  PIA1ACR=PIA1BCR=0;
  A=127;B=3; 
  PIA1ACR=PIA1BCR=PIA_DR;
  TMSK1=8;enable_interrupt();
  while(1);
}