Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » Anregungen » Java Bereich

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: [ 1 ] [ 2 ] [ 3 ] [ 4 ] [ 5 ] > 6 < [ 7 ]
050
29.11.2006, 22:58 Uhr
virtual
Sexiest Bit alive
(Operator)



Zitat von Reyx:
Wozu? Weil es inkonsistent ist. Ist eine Ganzzahl etwa kein Objekt? Oder ein Zeichen? Wieso ist ein Zeichen ein primitiver Datentyp, aber eine Zeichenkette nicht? Wieso ist ein Integer ein primitiver Datentyp (ich meine jetzt nicht die Klasse Integer), aber ein Array davon nicht?



Ja, es gibt eine Reihe von Leuten, die dies auch so sehen und entsprechende Programmiersprachen entwicklet haben (zB Smalltalk).


Zitat:

Und ich wage zu behaupten, dass es unter Java keinen sonderlichen Geschwindigkeitsunterschied macht, ob int nun ein primitiver Datentyp ist oder eine Klasse, die schlichtweg von Object abgeleitet wurde. Jeder Javaianer redet doch immer von den Laufzeitoptimierungen und dem Bytecode, wenn man Java als langsam bezeichnet; jetzt willst du mir verkaufen, dass eine einfache Kapselung da soo gravierend wäre?



Ich kenne mich mit den Internas nicht ausreichend aus. Bis Java 1.4 hätte ich genau das behauptet, nämlich daß es einen Laufzeitgewinn gibt. Belegen kann ich das nicht. In Java 5 wird mit dem in/Out Boxing von Primitves aber genau in diese Richtung gezielt, daß man an vielen Stellen die Wrapperklassen wie etwa Integer synonym zu den Primitives verwenden kann. In wie weit dies die Performance beeinflusst, kann ich nicht sagen, ich vermute aber, daß es schon einen nicht positiven Einfluss hat,
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
051
29.11.2006, 23:19 Uhr
Lensflare




Zitat von Reyx:

Wozu? Weil es inkonsistent ist.


Wieso ist Inkonsistenz deiner Meinung nach ein Nachteil?
Vorteil ist, dass Primitives schneller sind. Und wo wäre der Nachteil?


Zitat von Reyx:

Das mit den "Objektvarianten" halte ich auch nicht für sinnvoll; die einzigen wirklichen Einsatzzwecke waren bei mir bei Konversionen und dann, wenn ich Referenzen unbedingt brauchte (oder halt bei Object-Parametern). Aber dazu habe ich mich mit Java zu wenig beschäftigt, um daraus eine allgemeingültige Aussage treffen zu wollen.


Irgendwie widerspricht das deiner Argumentation darüber, dass die primitiven Typen auch Klassen sein sollten.
Du sagst ja eben selbst, dass du diese Objektvarianten meistens nicht brauchst.

EDIT:
eine primitive Variable muss doch auf jeden Fall schneller sein, als eine Referenz auf ein Objekt.
Bei der primitiven Variable liegt der Wert bereits drin und bei der Referenz muss erst einmal das Objekt geholt werden und dann daraus der Wert gelesen werden. Wenn ich nicht sogar ein paar Schritte überspringe.
--
Wenn das Gehirn so einfach wäre, dass wir es verstehen könnten, wären wir so einfach, dass wir es nicht verstehen könnten.
(Emerson Pugh Trost)

Dieser Post wurde am 29.11.2006 um 23:31 Uhr von Lensflare editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
052
30.11.2006, 09:41 Uhr
ao

(Operator)



Zitat von Reyx:
Wozu? Weil es inkonsistent ist.

Stimmt, ist es. Aber durch das Boxing ist die Inkonsistenz aufgehoben, und jedes Primitive kann, wenn nötig, wie ein Objekt aussehen.

Zitat:
Und ich wage zu behaupten, dass es unter Java keinen sonderlichen Geschwindigkeitsunterschied macht ...

Doch, ich glaub schon. Das ist nämlich der einzige Grund, der mir einfällt, warum sich die Sprachentwickler diese Unterscheidung und das Boxing antun.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
053
30.11.2006, 15:10 Uhr
J-jayz-Z
Perl Crack ala Carte
(Operator)



Zitat von Lensflare:
Aber kann mir jemand erklären wo eigentlich der Unterschied zwischen den beiden ist?
Also ich weiss nur, dass man Pointer inkrementieren kann usw.
Bei Referenzen geht das nicht.

Das liegt daran, das eine Referenz auf eine bestimmte Adresse im Speicher zeigt. Wenn du
C++:
int i = 12;
hast und &i ausgeben lässt, bekommst du die Adresse im Speicher, auf der die "12" liegt. Deshalb kannst du bei einer Referenz auch den Wert ändern, der dann auch außerhalb sichtbar ist. Weil du dann im Prinzip einen Wert direkt in den Speicher schreibst. Und auf diesen Wert zeigt dann die Variable "i". Bei einem Pointer ist das etwas anderst. Wenn du einen Pointer erzeugst, zeigt der Pointer auf irgendeine Stelle im Speicher, ohne zu wissen, was darunter liegt. Das beste beispiel ist
C++:
char* foo = "hallo";
. Ein "char" ist ein einzelnes Zeichen. Wieso kannst du dann 6 Zeichen da rein schreiben, obwohl eigentlich nur eins rein passt ? Das liegt daran, das der Pointer nun weiß: "Aha, an der Stelle beginnt der Inhalt". Und an dieser Stelle steht ein h. Dann steht als nächstes Zeichen ein a. Und so weiter. Bis zu NULL.
Beispiel:

C++:
#include <iostream>

int main(const int argc, const char* argv[])
{
    char *foo = "hallo";
    while(*foo != NULL)
    {
        std::cout << *foo << std::endl;
        *foo++;
    }
    std::cin.get();
    return EXIT_SUCCESS;
}

Etwas klarer ?
--
perl -Mstrict -Mwarnings -e 'package blub; sub new { bless {} } sub bar {my $self=shift; $self->{bla}="66756e2d736f66742e6465"; return $self->{bla};} my $foo=blub->new();print "Hallo ";print pack("H*",$foo->bar()); print "\n"'
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
054
30.11.2006, 17:10 Uhr
Lensflare




C++:
#include <stdio.h>

int main()
{
  int i = 17;
  int &r = i;  //Referenz auf i
  int *p = &i; //Pointer auf i
  
  printf(" i = %i  \n", i); //Wert von i
  printf("&i = %i\n\n",&i); //Adresse von i
  
  printf(" r = %i  \n", r); //Wert von i
  printf("&r = %i\n\n",&r); //Wert von r (= Adresse von i)
  
  printf(" p = %i  \n", p); //Wert von p (= Adresse von i)
  printf("*p = %i\n\n",*p); //Wert von i
  
  char *cp = "Hallo";
  char &cr = *cp;
  
  printf("*cp = %c\n",*cp); //erstes Zeichen von Hallo = 'H'
  printf(" cp = %i\n",cp);  //Adresse auf erstes Zeichen von Hallo
  printf("&cr = %i\n",&cr); //Adresse auf erstes Zeichen von Hallo
  printf(" cr = %c\n",cr);  //erstes Zeichen von Hallo = 'H'
  
  getchar();
}



Also einmal übergebe ich die Adresse von i einer Referenz und einmal einem Pointer.
Beide haben die Adresse als Wert und von beiden kann ich herausbekommen, was sich unter der Adresse befindet, nämlich 17

Beide Adressen sind identisch und zeigen auf die erste von den 4 Zellen, in denen sich die Zahl 17 befindet.

Das geht auch mit Zeichenketten. In meinem Beispiel habe ich eine Referenz erstellt, die auf den ersten Buchstaben von "Hallo" zeigt.

Der einzige Unterschied für mich ist, dass man den Wert des Pointers inkrementieren kann, womit dann der Pointer die nächste Adresse als Wert hat.
Und ich habe auch gemerkt, dass man Referenzen im Gegensatz zu Pointern immer initialisieren muss, so können sie schon mal nicht auf irgendeine ungewollte Stelle zeigen.

Ist das der Unterschied? Dass Referenzen "sicherer" sind?
--
Wenn das Gehirn so einfach wäre, dass wir es verstehen könnten, wären wir so einfach, dass wir es nicht verstehen könnten.
(Emerson Pugh Trost)

Dieser Post wurde am 30.11.2006 um 17:15 Uhr von Lensflare editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
055
30.11.2006, 21:48 Uhr
J-jayz-Z
Perl Crack ala Carte
(Operator)


Ok, nochmal. Der Unterschied von Referenzen und Pointern sind nur "oberflächlich".
Wir gehen einfach mal von der Adresse im Speicher aus. Eine Adresse im Speicher hat in einer Referenz folgende Bedeutung:
"Unter der Adresse 0xF89001 befindet sich der Wert 12"
Bei einem Pointer hat es aber eine andere Bedeutung:
"Ab der Adresse 0xF89001 fängt der unbekannte Wert an und hört beim nächsten NULL auf"
--
perl -Mstrict -Mwarnings -e 'package blub; sub new { bless {} } sub bar {my $self=shift; $self->{bla}="66756e2d736f66742e6465"; return $self->{bla};} my $foo=blub->new();print "Hallo ";print pack("H*",$foo->bar()); print "\n"'
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
056
30.11.2006, 23:16 Uhr
Guybrush Threepwood
Gefürchteter Pirat
(Operator)


Nein das ist falsch.

Im groben ist der Unterschied zwischen Pointern und Refernzen das man auf Referenzen keine Pointeraritmethik anwenden kann. Eine Referenz ist einfach ausgedrückt nur ein anderer Alias für eine Variable. Wenn man das genauer ausführen möchte muss man es afaik auf eine Sprache beziehen da sich Referenzen in verschiedenen Programmiersprachen unterscheiden.

Ein Pointer allerdings zeigt nicht immer in etwas unbekanntes und hörtmit einer binären NULL auf. Wenn man nicht wüßte worauf ein Pointer zeugt könnte man nicht viel mit ihm anfangen. Was du meinst sind vielleicht typisierte (z.B. ein int* oder char*) und nicht typisierte Zeiger (void*).
Die Binäre Null verwechelst du wahrscheinlich mit einen C-String, also einem char Array. Ein solches muss immer (sollte immer) mit einer Null aufhören, dabei ist es aber unerheblich ob man per Zeiger auf das Array zugreift. Wenn du einen Zeiger auf einen integer hast oder auf eine Funktion dann steht da auch keine Binäre Null am Ende.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
057
01.12.2006, 00:00 Uhr
Pler
Einer von Vielen
(Operator)


Ähm. J-jayz-Z. Ich denke, dass in deinem Programm eher != '\0' statt != NULL stehen soll.
NULL ist zwar am Ende auch nur 0, was wieder '\0' entspricht, aber wird ja normalerweise dazugenutzt, um einen NULL-Zeigen besser zu "signalisierten". Darum gibt's das Define ja überhaupt erst glaub ich.

Und *foo++ haut gar nicht hin. Wahrscheinlich hast du (*foo)++) gemeint; was aber genau falsch ist. foo++ wäre richtig.

Zu:
Zitat:
Ab der Adresse 0xF89001 fängt der unbekannte Wert an und hört beim nächsten NULL auf
Siehe die Antwort vom Piraten.
Und das Ende von einem Speicherbereich auf den ein Zeiger zeigt, weißt du nur dadurch, dass du weißt auf was der Zeiger zeigt.
Mit einem (*foo)++ könntest du - wenn es ein normales Feld wäre - aus einem a ein b machen.

Dieser Post wurde am 01.12.2006 um 00:14 Uhr von Pler editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
058
01.12.2006, 10:38 Uhr
Pablo
Supertux
(Operator)



Zitat von Pler:

NULL ist zwar am Ende auch nur 0, was wieder '\0' entspricht, aber wird ja normalerweise dazugenutzt, um einen NULL-Zeigen besser zu "signalisierten".


wobei man sagen muss, dann NULL nicht zwangsläufig der Zahl 0 entsprechen muss, diese Diskussion hatten wir aber schon vor langer Zeit (weiß nicht mehr, wo).
--
A! Elbereth Gilthoniel!
silivren penna míriel
o menel aglar elenath,
Gilthoniel, A! Elbereth!
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
059
01.12.2006, 11:59 Uhr
J-jayz-Z
Perl Crack ala Carte
(Operator)


Ist ja nicht so, das ich mich nicht gerne korrigieren lasse, aber wenn es (*foo)++ oder foo++ heißen müsste, wieso funktioniert mein obiges Snippet dann überhaupt ?
--
perl -Mstrict -Mwarnings -e 'package blub; sub new { bless {} } sub bar {my $self=shift; $self->{bla}="66756e2d736f66742e6465"; return $self->{bla};} my $foo=blub->new();print "Hallo ";print pack("H*",$foo->bar()); print "\n"'
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: [ 1 ] [ 2 ] [ 3 ] [ 4 ] [ 5 ] > 6 < [ 7 ]     [ Anregungen ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: