Referenz heißt, dass die Adresse eines anderen Speicherbereichs gespeichert wird (also auf den Speicher gezeigt wird).

Dereferenzieren heißt, du folgst der Adresse und greifst auf den Speicherbereich zu, von dem du die Adresse gespeichert hast.

Die Adresse ist die Adresse des Speicherbereichs, wo die variable gespeichert ist.

int orginal = 42; /*Erstelle variable*/
printf("Adresse: %d\n", & orginal); /*mit dem & vor der variable erhälst du die Adresse*/
int kopie = orginal; /*Kopiere des Orginals, hier wird der Inhalt kopiert*/
int *referenz;
refernez = &orginal; /*Erstelle eine Referenz die auf den Speicherbereich der variable Orginal zeigt, hier wird nichts kopiert*/
orginal = 0; /*Weil referenz auf den selben Speicher zeigt, ist *referenz nun auch 0*/
printf("orginal: %d, referenz: %d", orginal, *referenz); /*mit * vor der variable dereferenzierst du*/
printf("Speicheradresse orginal: %d, referenz: %d", &orginal, referenz); /*gibt beidesmal die Adresse vom orginal aus*/
referenz = &kopie; /*nun zeigt die referenz auf den Speicherbereich der variable kopie und somit auf 42*/
int **referenz2; /*man kann auch zeiger auf zeiger erstellen...*/
referenz2 = &referenz;
printf("Kopie referenziert: %d", **referenz2);
int ***referenz3;
referenz3 = &referenz2;
printf("Kopie referenziert: %d", ***referenz3);
/*uns so weiter*/
referenz = *orginal; /*nun zeigen referenz, referenz2, referenz3 wieder auf das orginal, also 0*/

Hoffe das ist einigermaßen verständlich. Ich weiß das das Thema in C/C++ nicht so einfach ist.

LG

Zu deiner 1. Frage: Es geht immer effizienter (z.B. mit Nutzung von C/C++ und/oder betriebs- oder prozessorspezifische Befehle). Dabei musst du dir immer die Frage stellen, ob es sinn macht. Und sinn macht es normalerweise nur dann, wenn das Programm zu langsam läuft. Dann machst du Performancetests und optimierst an den stellen, wo die meiste Laufzeit verbraucht wird. Problematisch ist bei Optimierungen, dass diese oft den Code schlechter Lesbar machen. Falls du aber mal einen einfachen hinweis haben willst, solltest du die Größe der List bei der Erstellung festsetzt (geht z.B. mit ArrayList):

List<Integer> output = new ArrayList<>(a.size() + b.size());

Dies verhindert unnötige Speicheroperationen wie Speichervergrößerungen oder das Kopieren von Speicher.

Zur 2. Frage, wie schon erwähnt, musst du das i.next() zwischenspeichern, sollte also so gehen:

while (i.hasNext()) {
  Double d = i.next()
  if (!((d > untergrenze) && (d < obergrenze))) i.remove();
}

Hallo, deine Frage macht wenig Sinn. Hier mal ein Link wo beschrieben ist, was eine Deklaration ist: http://javatricks.de/tricks/der-unterschied-zwischen-instanziieren-deklarieren-und-initialisieren

Anderer Seits kann eine Liste Deklariert werden aber noch nicht initialisiert, z.B.:

ArrayList<String> mehrereStrings; //Deklariert, aber nicht initalisiert

Was meinst du mit class-Dateien umwandeln? Dekompilieren zu .java? Zu .jar kompilieren? Oder noch was anderes?

In der 1. Zeile hast du 1 *, in der nächsten 2 mehr und wieder 2 mehr... Das machst du bis die Anzahl Sternchen größer wird als die Kantenlänge... Ist doch perfekt für eine For-Schleife... Ich geh mal davon aus, du weißt du x Sternchen in einer Zeile ausgibst. Die 2. for-Schleife beginnt mit der zuletzt ausgegebener Anzahl Sternchen -2 und geht bis 1. Ach wieder in 2er Schritten.

Hoffe es hilft dir :)

Also C bzw. C++ sind eigentlich auf jedem programmierbaren Geräte (= Rechnersysteme) zu nutzten. Dazu gehören Computer (z.B. Betriebssysteme), Handys, Roboter, Kühlschränke....

Also in deinem Beispiel würde ich auch sagen, dass der Konstruktorparameter der Parameter ist, der die Elementanzahl angibt, also 10 bzw. x. Wobei ich selbst noch nie das Wort Konstruktorparameter gehört habe.... Alles andere würde aber gar kein Sinn machen... LG

Es kann keiner in die Zukunft schauen. Programmierung gilt aktuell als ziemlich sicherer Arbeitsplatz, kann aber durch eine neue Erfindung oder Entwicklung auch einfach wegfallen oder stark reduziert werden.

Zu deiner Frage von KI: es gibt keine wirkliche bzw. sehr viele stark voneinander abweichende Definitionen von KI.... Vermutlich meinst du lernende Algorithmen. Dort wird eher ein Data Scientist benötigt, die die Lerndaten vorbereiten, sodass der Lernprozess erfolgreich ist. Meiner Meinung nach werden lernende Algorithmen dort genutzt, wo Programmierer keine Lust (zu Aufwendig) es direkt umzusetzten haben oder nicht wissen wie (keine Math. Problembeschreibung). I.d.R. sind aber die Ergebnisse Programmierter KI besser als lernender KI (wieder meine Meinung).

Hey,
ich hab nur immer mal wieder das Buch 1) genutzt, falls ich spezielle Probleme hatte (und andere Quellen). Das Buch 2) kenne ich nicht, es scheint aber anders zu sein, wenn ich mir mal das Inhaltsverzeichnis ansehe.
Das 1) Buch finde ich alles etwas Kurzgefasst und eher zu empfehlen, wenn man ungefähr weiß, worum es geht...
Was für ein Buch zu empfehlen ist, kann ich dir leider nicht sagen. Wenn du Bücher vergleichen willst, würde ich mir den Punkt Pointer/Zeiger und dynamische Speicherallokierung (malloc & free / new & delete) ansehen, weil dies ein Thema ist, was schwierig zu übermitteln ist und gearde in C zentral ist, finde ich zumindest.
Hoffe ich konnte dir Helfen : )

Wikipedia https://de.wikipedia.org/wiki/Wasserfallmodell mein zum Beispiel:

1. Anforderungsanalyse und -spezifikation (englisch Requirement analysis and specification) resultiert im Lastenheft
2. Systemdesign und -spezifikation (englisch System design and specification) resultiert in der Softwarearchitektur
3. Programmierung und Modultests (englisch Coding and module testing) resultiert in der eigentlichen Software
4. Integrations- und Systemtest (englisch Integration and system testing)
5. Auslieferung, Einsatz und Wartung (englisch Delivery, deployment and maintenance) 

Bei den Tests können/sollten dann noch die Tests protokolliert werden. Aus meiner Sicht gehört auch noch ein Pflichtenheft und Benutzerhandbuch (wenn gewünscht) dazu.

Der Unterschied ist nur der Takt. Wenn du die billigerere nimmst und Übertraktest, hast du nicht die gleiche Karte für weniger Geld. Im besten Fall hast du eine Karte die sich für eine Zeit lang gleich verhält. Oft ist Übertrakten mit einer höheren Wärmeentwicklung verbunden was auch die Lebensdauer verkürzen kann. Wenn halt eine Bestimmte Temperatur erreicht wird, wird die Leistung zum Schutz vor Überhitzung reduziert. Somit würde ich eben nur eine kurzzeitige Übertaktung empfehlen.

Außerdem kannst du die andere ja auch (kurzzeitig) Übertrakten, sodass diese wieder schneller ist....

Musst halt selber wissen, ob dir dieser "kleine" Taktunterschied das Geld wert ist und ob du ihn wirklich langfristig ausnutzten wirst.

PS: Um aber mal ehrlich zu sein, weiß ich auch garnicht ob da überhaupt verschiedene Hardware verbaut wird. In dem Fall würde es von der Temperatur und dann der Lebensdauer keinen unterschied machen.

Zumindest hast du kein Anspruch darauf, Punkte für Lösungen zu bekommen, die du durchgestrichen hast. Teilweise geben die, die solche Arbeiten korrigieren trotzdem Punkte. Wenn sie es aber nicht tun, dann ist es halt so...

Dazu solltest du dir mal die Funktion fork() ansehen, z.B. hier: https://www.tutorialspoint.com/fork-in-c
oder
http://timmurphy.org/2014/04/26/using-fork-in-cc-a-minimum-working-example/

Mit join() kann auf den Kindprozess gewartet werden. Normalerweise reicht dafür googeln, dort gibt es auch ausreichned Beispiele...

Zum warten kannst du sleep aus <unistd.h> benutzten.

LG

Müsste sowas in der Art sein (hier mal für nur Positive Zahlen, ohne Überlaufschutz und keiner richtiger Fehlerbehandlung falscher Eingaben):

int hexToInt(char* hex){
  int result = 0;
  for(char *c = hex; *c != 0; c++){
    if(*c <= 'F' && *c >= 'A')result = (result << 4)+10+(*c-'A');
    else if(*c <= 'f' && *c >= 'a')result = (result << 4)+10+(*c-'a');
    else if(*c <= '9' && *c <= '0')result = (result << 4)+(*c-'0');
    else return -1; //ungültige eingabe
  }
  return result;
}

Habs übrigens auch nicht getestet noch kompiliert....

Ich hab nun nach weiterm suchen folgende ClassLoader-Klasse geschrieben, die in dem Beispiel oben Funktioniert:

public class HotClassloader extends ClassLoader{
 String pfad;
 
 public HotClassloader(String pfad, ClassLoader loader) {
        super(loader);
  this.pfad = pfad;
    }
 public HotClassloader(String pfad) {
        super();
  this.pfad = pfad;
    }
 
 private byte[] holeBytes(String klasse) throws IOException, ClassNotFoundException {
        String klassenPfad = klasse.replace(".","/")+".class";
        try (JarFile jarFile = new JarFile(pfad)) {
            Enumeration<JarEntry> entries = jarFile.entries();
            while (entries.hasMoreElements()) {
                JarEntry entry = entries.nextElement();
                if (entry.getName().equals(klassenPfad)) {
                    InputStream inputStream = jarFile.getInputStream(entry);
                    return holeBytes(inputStream);
                }
            }
        }
        throw new ClassNotFoundException("ClassNotFoundException: "+klasse);
    }
 
 private byte[] holeBytes(InputStream is) throws IOException {
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        byte[] buffer = new byte[0xFFFF];
        for (int len; (len = is.read(buffer)) != -1;)
            os.write(buffer, 0, len);
        os.flush();
        return os.toByteArray();
    }
 
 @SuppressWarnings({ "unchecked", "rawtypes" })
 public Class loadClass(String klass) throws ClassNotFoundException {
  if(klass.substring(0,4).equals("java"))return super.loadClass(klass);
        try {
         byte[] classData = holeBytes(klass);
            return defineClass(klass,
                    classData, 0, classData.length);
        } catch (IOException e) {
         e.printStackTrace();
            throw new ClassNotFoundException();
        }
    }
}

Dazu muss der URLClassLoader durch diese Klasse ersetzt und der Konstruktor entsprechend angepasst werden.

Vielleicht Hillft es ja jmd in Zukunft : )
PS: Es würde logischerweise auch schöner gehen an einigen Stellen....

ist es nicht viel billiger eine microSD-Karte zu kaufen und ein Smartphone, welches ein Steckplatz für eine hat?...

säubern ist auf jedenfall das Richtige! Spiele erfordern ziehmlich viel Speicher usw. sodass dein PC/Laptop

1. mehr strom aufnimmt
2. schnell warm/heiß wird

Also ist das ganz normal, aber warscheinlich nicht besonders "gesund"... Ich habe mal sogenannte "Cooling Pads" gesehen, leider dazu keine Erfahrung gesammelt....

du rufst die Funktion auf, wo speicherst du denn den Rückgabewert?

 potenz(zahl, potenzZahl);

richtig wäre zB dass:

double returnValue =  potenz(zahl, potenzZahl);
...
cout<<returnValue

oder

cout<<potenz(zahl, potenzZahl);

auserdem kannst du die Funktion "potenz" noch etwas kürzen:

double potenz(double zahl, int potenzZahl)
{
    return pow(zahl, potenzZahl);
}

aus meiner sicht solltest du dieses Thema nocheinmal in angriff nehmen...

double potenz (double basis, int potenz);

double potenz (double basis, int potenz)
{
    if (potenz < 0) return(1/potenz(basis,((-1)*potenz)));
    else if (potenz == 0) return 1;
    else if (potenz == 1) return basis;
    else return (basis*potenz(basis, (potenz - 1)));
}

hoffe, dass es läuft, habe nicht getestet... die main kriegst du schon alleine hin ;)

HUND999

Buch oder Tutorial (ich persönlich finde Buch besser), wenn du etwas nicht richtig verstehst hilft dir google.de bestimmt... ;)