Allein die Tatsache, dass du hier fragen musst, zeigt, dass es dir an Erfahrung mangelt. (Das ist NICHT böse gemeint, sondern nur eine Feststellung! Jeder hat mal klein angefangen, ich auch!)

Normalerweise ist es für Einsteiger ohne besagte Erfahrung sehr riskant, eigene Websites mit PHP zu entwickeln, weil sie sich überhaupt nicht über gängige Sicherheitslücken im Klaren sind, und unter Garantie auch in kleinere / einfachere Seiten, entsprechend ausnutzbare Fehler einbauen werden.

Von daher würde ich in deinem Falle für eine fertige Lösung plädieren.

Aaaaaber, WP ist mit gaaaaaaaanz weitem Abstand das CMS (was selbst eigentlich kein CMS sein will), welches am häufigsten gehackt wird. Das passiert in größerem Umfang alle paar Wochen oder spätestens Monate. Oft sind daran schlampig programmierte Plug-Ins schuld, oft aber auch wieder nicht, und es handelt sich wirklich um schwere Fehler in der Kern-Software.

Fazit: Du hast die Wahl zwischen Teufel und Beelzebub. :)

Egal wofür du dich entscheidest, du kannst sicher davon ausgehen, dass deine Website gehackt werden wird. Und das sogar - wenn du Pech hast - relativ zeitnah.

Bei WP oder einer anderen fertigen Lösung, kannst du die Schuld zwar teilweise auf andere schieben, aber das bringt dir die geklauten Nutzerdaten auch nicht zurück, bzw. musst du dann so oder so deine gesamte Website neu aufsetzen, um sicher zu stellen, dass keine Seiten trojanisiert wurden und munter Malware an die Besucher verteilen.

Was auch immer du tust, mache dir VORHER einen detaillierten Plan, was du tun wirst, wenn es soweit ist, dass deine Website gehackt wird:

  • Wie wirst du registrierte Nutzer informieren?
  • Haust du eine Art Pressemitteilung raus, die du als Textbausteine ja auch schon mal vorbereiten kannst?
  • Automatisierst du ein Rückspielen deiner Webpräsenz aus einem "sauberen" Backup?
  • ... Es gibt unzählige Fragen, über die du dir bei Zeiten Gedanken machen solltest.

Die einzige Möglichkeit, die Gefahr "gehackt" zu werden, auf ein erträgliches Maß zu senken, ist a) Profis für viel Geld anstellen oder b) selbst zum Profi werden. Aber da Punkt b) viele Jahre Zeit in Anspruch nehmen wird, bleibt dir nur Punkt a) oder du musst - wie oben erwähnt - mit einem erhöhten Risiko leben.

Sei dir auf jeden Fall der Gefahr bewusst, ob du etwas dagegen unternimmst, oder nicht. Wordpress installieren und ab dann "Augen zu" wird nicht funktionieren. Außerdem gibt es mit der neuen DSGVO empfindliche Strafen, auch für Blogbetreiber, wenn sich diese nicht entsprechend um die Sicherheit kümmern.

Ich weiß, das war jetzt nicht die Antwort, die du haben wolltest, aber du konntest hoffentlich etwas mitnehmen. :)

Schönen Tag noch, und trotzdem viel Erfolg mit deiner Website! :)
...zur Antwort

Die bedeuten das gleiche wie "quod erat demonstrandum". :)

...zur Antwort

Wenn die Zahlen als Strings in einer Liste vorliegen, kannst du ganz einfach mit ...

int_list = list(int(x) for x in str_list)

... eine int-Liste daraus machen. :)

Hättest du mal ein paar Zeilen des Inhalts deiner Textdatei gepostet, wüsste man das genaue Format und könnte evtl. auch noch sagen, wie du die möglichst elegant parsen kannst, aber ohne weitere Infos geht das leider nicht. Sorry. ><

...zur Antwort

Gleitpunktzahlen - zumindest die Sorte, von der wir hier reden - kannst du in sehr vielen Fällen sowieso nicht exakt runden.

Außerdem würde ich an deiner Stelle keinen ellenlangen Formel-Schwanz produzieren, sondern die eigentliche Berechnung und die Rundung in (mindestens) zwei getrennte Zeilen aufteilen.

Nach der Berechnung sähe eine Annäherung auf drei Nachkommastellen so aus:

gz = Math.round(gz * 1000.0) / 1000.0;

Aber nochmal, exakte Rundungen wirst du prinzipbedingt mit den gängigen Gleitpunkttypen Javas nicht hinbekommen können. (ob mit oder ohne "strictfp") Außerdem hängt das bei der IEEE 754 Repräsentation auch noch extrem stark vom eigentlichen Wert ab.

Java bietet eine genauere Klasse für Gleitpunktzahlen an, nämlich BigDecimal, die auch über mehr Rundungsmöglichkeiten verfügt, aaaaaber soweit ich mich recht erinnere, arbeitet diese Klasse intern nicht wie IEEE 754-2008, also dezimal, sondern binär, was eine exakte Rundung unmöglich macht.

Du müsstest dir also entweder eine eigene Klasse bauen (was gar nicht soooo schwer ist!) oder auf eine fertige Bibliothek zurück greifen. Allerdings dürfte für deinen Falle die Rundung aus dem Einzeiler-Snippet locker ausreichen, und man muss ja nicht mit Kanonen auf Spatzen schießen. :)

Naja, trotzdem viel Erfolg! :)
...zur Antwort

Vorweg: Du meinst keine Variablen-, sondern Literal-Suffixe. Zu Variablensuffixen gibt es auch viel zu erzählen, aber das ist ein anderes Thema ...

Literalsuffixe sind - gerade bei "float" - extrem wichtig!

Wenn du einen double-Literal nutzt, um eine float-Variable zu initialisieren oder einen neuen Wert zuzuweisen (oder umgekehrt), dann kommt es intern zu einem impliziten Casting, der in sehr vielen Fällen einige Bits Datenverlust mit sich führt.

Demonstration:
#include <ios> // boolalpha
#include <iostream> // cout, endl

int main(void) {
	using namespace ::std;

	cout << boolalpha;

	float a = 0.1234f;
	cout << "a: " << (a == 0.1234f) << endl;

	float b = 0.1234;
	cout << "b: " << (b == 0.1234) << endl;
}

Die Ausgabe lautet:

a: true
b: false

Und das nur, wegen dem ollen Suffix! Gemein, oder? Guck dir bitte ganz genau an, welche Literale über ein angehängtes "f" verfügen, und welche nicht!

Der obige Effekt ist übrigens einer der Gründe dafür, warum man Gleitpunktzahlen niemals direkt mit "==" auf Gleichheit prüfen sollte, aber das nur am Rande ...

Wie du siehst, ist dieses "sinnlose" Suffix doch manchmal gar nicht sooooooooo "sinnlos". :)

Fazit:

Wenn du innerhalb von Berechnungen / Algorithmen schwer auffindbare Fehler vermeiden willst, nutze immer die Suffixe (falls vorhanden), die zu deinen Variablentypen passen.

Das gilt insbesondere bei C++ noch viel stärker, als bei C, allein schon wegen der neuen universellen Initialisierung, der Überladung aus dem Beispiel von Isendrak oder noch extremer bei der Programmierung mit Templates. (Nichts dieser exklusiven C++ Features existiert bei C.)

Meine und die Antworten der anderen decken übrigens nicht alle Gründe FÜR die Literalsuffixe ab, es gibt dazu noch mehr zu wissen, aber ich will das hier jetzt nicht zu sehr in die Länge ziehen. (Habe unter der Antwort von PeterLustig1999 schon einen Roman verfasst ... sorry!) ><

Also dann ... schönen Tag noch! :)
...zur Antwort

Beide Verfahren funktionieren komplett unterschiedlich, und weil RSA extrem rechenaufwändig ist, wird meistens nur der Schlüssel für einen der AES-Algorithmen damit verschlüsselt, um damit anschließend wiederum die eigentlichen Daten ver- und entschlüsseln zu können.

Außerdem ist AES ein Blockchiffre und um das selbe mit RSA schaffen zu können, müsste man einen nicht sonderlich optimalen / effizienten der vielen Betriebsmodi nutzen.

Kauf dir mal dieses Buch, und lies es dir durch:

https://www.amazon.de/Kryptografie-Verfahren-Protokolle-Infrastrukturen-iX/dp/3864903564/ref=sr_1_2

Ist recht dick, aber auch recht anspruchslos. Mathematik brauchst du dafür fast gar keine, und wenn du mehr ins Detail gehen willst, solltest du danach noch andere Bücher lesen. Nichtsdestotrotz bietet es einen sehr guten Überblick über das Thema, und du wirst danach auch wissen, warum man deine Frage eigentlich nicht beantworten kann.

Um Grundbegriffe wie S-Boxen oder Feistelchiffre verstehen, und den grundlegenden Aufbau gängiger Algorithmen nachvollziehen zu können, ist das Buch aber sehr gut geeignet. Es hat zwar viele Seiten, liest sich aber auch ohne größeren Hirneinsatz sehr leicht.

Viel Spaß beim Lesen! ;)

PS: Deine Frage erinnert mich an meine Experimente mit großen Schlüssellängen. Der hier hat 32768 Bit:

-----BEGIN PUBLIC KEY-----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-----END PUBLIC KEY-----

GPG hat Probleme damit, solche großen Schlüssel zu erzeugen, weshalb man erst eine total sinnlose Prüfung auf einen Maximalwert (von 8192 glaube ich) rauspatchen muss, aber danach kommt sowohl GPG als auch OpenSSL und auch alle anderen Softwaren damit klar. :)

...zur Antwort

Die anderen Antworten mit <climits> bzw. <limits.h> beziehen sich auf die veralteten Makrodefinitionen aus C-Zeiten und sollten ausdrücklich nicht mehr genutzt werden. Zumal du diese nicht bei der Template-Programmierung einsetzen kannst und sie viele weitere Nachteile mit sich bringen.

Nutze bei C++ bitte ausschließlich "numeric_limits" aus <limits>, so wie aus der Antwort von "Destranix".

Beispiel um den Minimal- und Maximalwert eines Integers auszugeben:

#include <iostream> // cout, endl
#include <limits> // numeric_limits

// ...

using namespace ::std;

cout << "int min: " << numeric_limits<int>::min() << endl;
cout << "int max: " << numeric_limits<int>::max() << endl;

Beachte auch die anderen praktischen Member des numeric_limits-Templates hinter dem Link aus Destranix' Antwort. :)

Schönen Tag noch! :)
...zur Antwort

Ich finde die Aufgabenstellung etwas merkwürdig, da sie gerade für Anfänger nicht lösbar ist. Sogar für viele Fortgeschrittene dürfte die Aufgabe ohne schmutzige Tricks kaum lösbar sein.

Hier ist mein Ansatz mithilfe der Reflection-API:
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class Main {

	private static String findValueFieldName() throws Exception {
		for (final Field field : Integer.class.getDeclaredFields()) {
			if (!Modifier.isPrivate(field.getModifiers())) {
				continue;
			}

			final Class<?> type = field.getType();
			if (!type.isPrimitive() || !type.toString().equals("int")) {
				continue;
			}

			return field.getName();
		}

		throw new RuntimeException("no value field found");
	}

	public static void swap(Integer a, Integer b) throws Exception {
		final String valueName = findValueFieldName();

		Field valField = Integer.class.getDeclaredField(valueName);
		valField.setAccessible(true);

		Field modField = Field.class.getDeclaredField("modifiers");
		modField.setAccessible(true);

		modField.setInt(valField, valField.getModifiers() & ~Modifier.FINAL);

		final Integer tmp = new Integer(a);

		valField.set(a, b);
		valField.set(b, tmp);
	}

	public static void main(String[] args) throws Exception {
		Integer a = 123;
		Integer b = 456;
		System.out.printf("a = %d; b = %d\n", a, b);

		swap(a, b);
		System.out.printf("a = %d; b = %d\n", a, b);
	}

}

Dabei mache ich mir das java-typische Autoboxing zunutze. Die Ausgabe lautet:

a = 123; b = 456
a = 456; b = 123

Dazu noch folgende Bemerkungen:

  • Ja, ich weiß, dass man einem Entwickler dafür den Kopf abreißen sollte, wenn er so anfängt. :)
  • Ein Anfänger muss das noch lange nicht nachvollziehen können.
  • Die Funktionsweise ist sehr fragil und hängt sowohl von der Implementierung einiger Klassen im JRE als auch den Optimierungen des Compilers ab. (Deshalb auch notgedrungen die merkwürdige Deklaration der Variablen "tmp", die normalerweise vom Compiler wegoptimiert wird.)
  • Ich werde das Gefühl nicht los, dass die Aufgabe einfach nur total schlecht formuliert ist ... kann mir beim besten Willen nicht vorstellen, dass es sich um eine Frage für Einsteiger handeln soll.

Naja, viel Erfolg noch beim Lernen, und lass dich bitte nicht vom obigen (grauenhaften) Reflection-Code abschrecken. Normalerweise läuft dir so etwas bei ordentlicher Programmierung eigentlich niemals über den Weg. Nimm meinen Code einfach als "schlechtes und abschreckendes" Beispiel! ;)

Schönen Tag noch! :)
...zur Antwort
abfallstoff abscheidungsstoff absorptionsfarbstoff 
abwehrstoff adsorbatimpfstoff allergiestoff alpakastoff 
anilinfarbstoff ansteckungsstoff anstrichstoff anzugstoff 
aromastoff arsenwasserstoff augenreizstoff ausgangsstoff 
auslegungsbrennstoff bambuszellstoff bandagenstoff 
basisrohstoff bastelklebstoff baumwollhalbstoff 
baumwollstoff baumwollzellstoff baustoff bauststoff 
bedruckstoff bergangswerkstoff berträgerstoff 
beschichtungsstoff betonzuschlagstoff betriebsstoff 
bezugsstoff biokraftstoff bisulfitzellstoff bitterstoff 
blattinhaltsstoff blaufarbstoff blutfarbstoff 
bodennährstoff bootsverdeckstoff bremsbelagklebestoff 
brennstoff brokatstoff buchbinderklebstoff chemierohstoff 
chlorkohlenwasserstoff chlorwasserstoff chromfarbstoff 
cyanacrylatklebstoff cyanwasserstoff dekostoff dichtstoff 
dieselkraftstoff direktfarbstoff dispersionsklebstoff 
dotierungsstoff druckwasserstoff duftstoff düsentreibstoff 
eigenimpfstoff eisenwerkstoff elastikstoff 
elastomerwerkstoff elektroisolierstoff elektronikgrundstoff 
elektronikklebstoff energierohstoff epoxidharzklebstoff 
ersatzbrennstoff explosivstoff farbstoff faserstoff 
faserverbundwerkstoff feststoff filzstoff 
fleischersatzstoff fremdstoff füllstoff füllsüßstoff 
futterstoff gallenfarbstoff gärungsstoff gefahrstoff 
gelbfieberimpfstoff gerbstoff gerinnungsstoff geruchsstoff 
geschmacksstoff geschmackstoff gesprächsstoff giftstoff 
grundstoff grundwerkstoff gummistoff harnstoff hemdenstoff 
hemmstoff hilfsstoff holzwerkstoff hopfenbitterstoff 
hornstoff huminstoff impfstoff inlettstoff isolierstoff 
isolierwerkstoff jacquardstoff jeansstoff kampfstoff 
kationfarbstoff kernbrennstoff klebstoff kohlenstoff 
kohlenwasserstoff konfliktstoff konservierungsstoff 
kontaminationsstoff kraftstoff krankheitsstoff 
kühlschmierstoff kunststoff küpenfarbstoff 
lebensmittelfarbstoff lebensmittelrohstoff 
lebensmittelzusatzstoff lehrstoff leichtzuschlagstoff 
lernstoff lesestoff leuchtstoff luftschadstoff mineralstoff 
monotreibstoff nährstoff nahrungskettenschadstoff 
oberstoff ottokraftstoff plastiksprengstoff prüfungsstoff 
raketentreibstoff reaktivfarbstoff reaktorwerkstoff 
reizstoff reststoff rohbrennstoff rohstoff rötelnimpfstoff 
rötelnlebendvirusimpfstoff sauerstoff säurefarbstoff 
schadstoff schaumkunststoff schaumstoff schichtpressstoff 
schichtpreßstoff schichtstoff schmierstoff schmutzstoff 
schutzstoff schwebstoff schwefelfarbstoff 
schwefelkohlenstoff schwefelwasserstoff 
schweißzusatzwerkstoff seidenstoff sicherheitssprengstoff 
spengstoff sprengmittelkennstoff sprengstoff spurenstoff 
stickstoff stoff suchtstoff süßstoff 
tetrachlorkohlenstoff trägerstoff treibstoff trockenstoff 
unterrichtsstoff urstoff velourstoff verbandstoff 
verbundwerkstoff verseuchungsstoff vliesstoff wasserstoff 
weichstoff werkstoff wertstoff wirkstoff wollstoff 
zellstoff zündstoff zusatzstoff zuschlagsstoff 
zuschlagstoff zwischenlagenwerkstoff 
...zur Antwort

Für Kali-Linux reicht auch ein mehrere Jahre alter gebrauchter Laptop für 20€ bis 30€ völlig aus, und es wird absolut flüssig laufen.

Ich nutze zwar kein Kali, aber diverse andere Linuxe und BSDs laufen bei mir auf Rechnern von 2008 absolut problemlos ... und ab und zu mal einen Videostream gucken geht auch Problemlos damit.

Fazit: Für dein Budget von 200€ bis 300€ bekommst du bei eBay gleich 10 ausreichende Laptops! ;)

PS: Ein RasPi oder andere Einplatinencomputerchen sind auch schicke Alternativen, falls du mal irgendwas auf einer ARM-Plattform ausprobieren willst. :)

...zur Antwort

Du verwendest grundsätzlich die Datentypen, die am besten geeignet sind. Und was genau "geeignet" bedeutet, hängt vom Einzelfall ab. :)

Als grobe Richtlinien kannst du folgende Hinweise beachten, die sich wohlgemerkt nicht ausschließlich auf die reinen Typen beziehen:

  • Keine Gleitkommatypen als Zählvariablen in Schleifen verwenden.
  • Niemals Gleitpunkttypen mit "==" vergleichen.
  • Variablen (egal welchen Typs) immer als "const" deklarieren, falls diese später nicht mehr geändert werden. Das gleiche gilt für Funktionsparameter. "Recycling" von Variablen vermeiden.
  • Ganzzahltypen immer so klein wie möglich wählen, aber so, dass der höchstmögliche Wert des vorliegenden Anwendungsfalls immer noch darin Platz findet.
  • Vorzeichenbehaftete Typen nur dann nutzen, wenn Vorzeichen auch benötigt werden.
  • Bei einer Division von Vorzeichenbehafteten Ganzzahlen nicht nur darauf prüfen, ob der Divisor Null ist, sondern auch, ob dieser den Kleinstmöglichen Wert darstellt. (Im Falle von "int" wäre das dann INT_MIN aus <limits.h>)
  • "char" oder "int" (auch als "unsigned") verwenden, wenn es auf Geschwindigkeit ankommt. (siehe dazu auch die [u]int_fastX_t Typdefinitionen aus <stdint.h>)
  • Einen Index mit kleinem Typen (z. B. "unsigned char") in eine Tabelle einem "dicken" Zeiger vorziehen, vor allem, wenn es sehr viele davon gibt. (z. B. Bitmaps mit Farbpalette)
  • Eventuell Festkomma-Aritmetik mit stinknormalen Integern in Betracht ziehen.
  • Falls nötig, Bibliotheken für sehr große Typen mit beliebiger Genauigkeit nutzen. (gibt es sowohl für Ganz- als auch Gleitpunktzahlen)
  • Unter Umständen mit Nibbles und Shifting / Maskierungen arbeiten, wenn es auf Speicherplatz ankommt. (Denke auch an Dinge wie BCD-Zahlen.)
  • Nicht vergessen, dass es auch (nicht Standard-C) Minifloats (oft 8 oder 16 Bit breit) und Gleitpunkttypen mit erweiterter Genauigkeit (meist 80 oder 128 Bit breit) gibt, je nach Compiler- und Plattform-Unterstützung.
  • Nutze für weitestgehende Plattformunabhängigkeit die Typdefinitionen aus <stdint.h>, falls du nicht auf ein eingeschränktes Subset von C angewiesen bist.
  • Verwende NIEMALS wchar_t von C++. (falls du nach C irgendwann mal auf C++ umsattelst)
  • Die Schlüsselwörter "auto", "volatile" und "register" nicht nutzen, es sei denn, du weißt genau, dass diese veraltet sind, was sie bedeuten, und kannst Nebeneffekte einschätzen.
  • Lerne die Eigenheiten und Unterschiede von / zwischen Zeigern und Arrays.
  • Beschäftige dich damit, was Speicherklassen sind, wie Paging funktioniert, was W^X oder ASLR heißt, was ein Program-Break ist und denke immer daran, dass es neben Stack und Heap auch noch allerhand "andere" Segmente gibt.
  • Informiere dich, was ptrdiff_t aus <stddef.h> mit void-Zeigern zu tun hat.
  • Setze das "restrict" Schlüsselwort sinnvoll ein, wenn du mit Puffern arbeitest.

... das sind aber alles keine feststehenden Naturgesetze, und u. U. kann / sollte / darf / muss man dagegen verstoßen. Mit der Zeit wirst du ein Gefühl dafür bekommen.

Viele der obigen Punkte werden ich jetzt vermutlich erschlagen, aber du musst diese (noch lange nicht vollständige!) Liste ja auch nicht an einem Abend durchackern. :)

Ich weiß, dass Code-Beispiele mehr als tausend Worte sagen, aber ich habe jetzt keine Zeit mehr, mir zu jedem der obigen Punkte ein Snippet aus den Fingern zu saugen. Falls noch Fragen offen sind, und ich nicht auf Kommentare reagieren sollte (habe in letzter Zeit viel zu tun) stell hier einfach direkt auf GF noch eine weitere Frage zu dem Thema ... irgendjemand wird dir schon Antworten. :)

Viel Spaß! :)
...zur Antwort

Aus diesem Grunde hat sich für Ein- und Ausgaben doch die Überladung der Shiftoperatoren eingebürgert:

#include <iostream> // cout, endl
#include <fstream> // ofstream

#include <ostream>

namespace gfx {

struct Point {
  int x;
  int y;
};

::std::ostream & operator << (::std::ostream & os, const Point & p) {
  return os << "Point { " << p.x << ", " << p.y << " }";
}

} // namespace

int main(void) {
	using namespace ::std;

	gfx::Point offset { 123, 456 };

	offset.x += 1111;
	offset.y += 5222;

	cout << offset << endl;

	ofstream ofs { "point.log" };
	ofs << offset << endl;
}

Das Programm gibt dir folgenden Text aus:

Point { 1234, 5678 }

Die selbe Ausgabe findet sich in der Datei "point.log". Der Grund, warum du also niemals direkt in ::std::cout schreiben solltest ist, weil du dich damit der Flexibilität beraubst, deine Ausgabe jederzeit beliebig umleiten zu können!

Der Vorteil dabei ist, dass du jede Form von Ausgabestrom nutzen kannst. Spezielle Ausgabefunktionen sollte man i. d. R. niemals schreiben, es sei denn, es gibt einen wirklich guten (!) Grund dafür. (z. B. eine Ausgabe in einem speziellen JSON- oder XML-Format, oder binäre Ausgabe)

Außerdem sollte die Ausgabe bei überladenem Shift-Operator so knapp wie möglich sein, und nicht mit einem Zeilentrenner abschließen, sodass der Aufrufer jederzeit selbst entscheiden kann, wie er die textuelle Repräsentation deiner speziellen Typen in seine eigene Ausgabe einbauen möchte.

Apropos "Repräsentation": Bei Python wird ordentlich zwischen str() und repr() unterschieden. So etwas muss man in C++ per Hand nachbauen, ist aber sehr angenehm, wenn man die Formatierung für interne Logs und Endbenutzer aufteilen möchte. Trotzdem empfiehlt sich natürlich immer ein "vernünftiger" Logging-Framework bei "richtigen" Projekten ... aber naja ...

Viel Spaß noch beim Programmieren! :)
...zur Antwort

Die Codeformatierung hier auf GF hat deinen Code so versaut, dass alle bisherigen Antwortenden deine Frage komplett missverstanden haben.

Ich wette, dein Code sollte eigentlich so aussehen:

char * s = "Hello, world!";

Und das ist kein gültiges C oder C++, sodass dir jeder vernünftige Compiler eine Warnung bzw. Fehlermeldung ausgeben wird! Soweit also kein Wunder! ;)

Der Grund dafür ist, dass "Hello, world!" ein konstanter Literal ist. Dieser wird vom Compiler in einem Speicherbereich abgelegt, der nicht schreibbar, bzw. nur lesbar ist. (Das ist zwar genau genommen Plattform- und Compilerabhängig, erspart einem aber viel Kopfzerbrechen, wenn man das im Hinterkopf behält.)

Die Adresse des String-Literals "Hello, World!" kann also nur einem Zeiger zugewiesen werden, der auf "unveränderliche" (aka "konstante") Speicherbereiche zeigt.

Deshalb ist nur (!) das hier richtig:

const char * s = "abc";

Falls du hingegen - was oft vorkommt - den String nach der Zuweisung auch noch bearbeiten / verändern willst, solltest du den konstanten Literal "Hello, world!" dazu nutzen, um ein Array mit automatischer Größe zu initialisieren:

char s[] = "abc";

Jetzt könntest du ganz legitim irgendwo in deinem Code ...

s[0] = 'd':
s[1] = 'e';
s[2] = 'f';

... schreiben, sodass dein String jetzt "def" enthält. Das geht, weil der Compiler so ein Array eben NICHT im Speicher für unveränderliche Werte ablegt.

Beachte bitte auch, dass das Array nicht die Größe 3, sondern die Größe 4 hat, da implizit ein abschließendes Nullzeichen '\0' an der vierten Position mit Index 3 (s[3]) steht.

Das ist einer der vielen gravierenden Unterschiede zwischen Zeigern und Array, die von Einsteigern gerne mal durcheinander gebracht werden. Du bist also nicht der einzige, mit diesem Problem. :)

Beachte bitte auch, dass "const char *" ein "Zeiger auf ein konstantes Zeichen" und kein "Zeiger auf ein Zeichen", geschweige denn ein "konstanter Zeiger auf ein Zeichen" oder ein "konstanter Zeiger auf ein konstantes Zeichen" ist! ;)

Wenn du jetzt verwirrt bist, hier ein paar Beispiele:

char * s; // Zeiger auf Zeichen: beide veränderbar
const char * s; // Zeiger auf konst. Zeichen: nur Zeiger veränderbar
char * const s; // konst. Zeiger auf Zeichen: nur Zeichen veränderbar
const char * const s; konst. Zeiger auf konst. Zeichen: nichts änderbar

Ein guter Trick dabei ist, die Definition rückwärts (!) zu lesen. Die vierte Zeile vom vorherigen Beispiel würdest du dann lesen als: "s ist ein konstanter Zeiger auf eine char-Konstante".

Merk dir diese Eselsbrücke, denn sie wird dir die Arbeit oft stark erleichtern! (Bei Arrays und Funktionszeigern funktioniert das nicht ganz so einfach, aber das würde jetzt den Rahmen sprengen, also lassen wird das jetzt mal unter den Tisch fallen.)

Falls dir das jetzt alles noch nicht schlüssig erscheint, keine Sorge! Lern einfach weiter, und irgendwann macht es dann schon "Klick".

Fazit: Strings, die du nicht mehr verändern willst, als konstante Zeiger deklarieren, ansonsten als Array. So einfach ist das! ;)

Schönen Tag noch! :)

PS: Die obigen Aussagen beziehen sich größtenteils auf den reinen C-Teil von C++. Wenn du irgendwann mal fortgeschritten bist, solltest du - wie andere schon geschrieben haben - für Strings die entsprechende Klasse aus der STL nutzen, also ::std::string aus <string>.

Trotzdem ist es natürlich enorm wichtig, erst mal die Basics zu kennen und zu verstehen, wozu natürlich auch die Unterschiede zwischen Zeigern und Arrays zählen. :)

...zur Antwort

Ja, das geht, sogar ziemlich erfolgreich. Meine Schwester hat das sowohl mit Hühnereiern und Wachteleiern geschafft, und hatte die dann einige Jahre als Haustiere gehalten.

Wie sie das genau gemacht hat, weiß ich ehrlich gesagt nicht, aber sie hatte definitiv nur "Haushaltsutensilien" benutzt, und nicht mal eine Wärmedecke o. ä. benötigt. Ich weiß aber, dass sie die Eier ständig umher gekullert hat, weil langes Liegen wohl schlecht für die Küken ist.

Beim Schlüpfen hat sie geholfen, und musst sich in den ersten Tagen / Wochen fast pausenlos um die unbeholfenen Küken kümmern.

Fazit: Es geht! :)

...zur Antwort
Das sollte gehen! :)

Du kannst die Audiospur extrahieren, und es so machen, wie in meinem Kommentar unter der Antwort von "manni94" beschrieben.

Das geht, ist keine große Sache, aaaaaber du wirst realistisch betrachtet die Stimme a) nicht zu 100% perfekt rausfiltern können und b) mit weiteren Qualitätseinbußen leben müssen, da ja Informationen vom Audiosignal entfernt werden ... und das hat nun mal Nachteile.

Allerdings stammt die Szene ja aus dem Spiel "Far Cry", und da liegt die Hintergrundmusik vermutlich sowieso als eigene Spur in den Assets vor. Du müsstest also eigentlich nur die Assets durchsuchen, und hättest dann eine Tonaufnahme der Hintergrundmusik in bester Qualität ohne irgendwas filtern zu müssen.

Dafür brauchst du aber sicher zusätzliche Software, die entsprechende Containerformate des Spiels extrahieren kann ... frag mich bitte nicht dazu, sondern google selbst, wie das geht.

Also dann ... viel Spaß! ;)
...zur Antwort

Gerade Word ist bekannt dafür, Artefakte und Datenmüll in Dokumenten und exportierten PDFs zu hinterlassen.

Da es dir ja direkt um "Korrekturen" geht: Ja, genau diese finden sich in aus Word exportierten PDFs. So etwas kann man zwar nicht mit einem "normalen" PDF-Betrachter sehen, aber mit spezieller Software zur Bearbeitung der Struktur von PDFs, ist das - gerade für Fachkundige Personen - relativ leicht möglich.

...zur Antwort

Viele QR-Codes sind von Designern erstellt, die sich noch nie Gedanken über die Spezifikationen für QR-Codes gemacht haben. (v. a. Randbreite, Punktgröße, Redundanz und "zerstörbare" Bereiche, etc.)

Guck mal hier:

Bild zum Beitrag

Dieser Design-QR-Code sieht auf den ersten Blick zwar nicht so aus, erfüllt aber alle Anforderungen der Spezifikation und sollte deshalb auch von jedem QR-Scanner gelesen werden können.

Wenn ein Scanner das lesen kann, dann sollte er eigentlich auch bei anderen QR-Codes funktionieren.

Was auch sein kann ist, dass viele Designer einfach zu viele Informationen in ihre QR-Codes packen, und viele günstigere Handymodelle das dann aufgrund zu geringer Auflösung nicht mehr lesen können.

Naja, viel Erfolg noch bei der Suche, nach einem guten QR-Code Scanner. (Ich habe jetzt keine Lust nachzugucken, welchen ich verwende ... aber die anderen Antwortenden haben dir ja schon genügend Hinweise gegeben.)

Schönen Tag noch! :)
...zur Antwort

Ich weiß nicht warum, aber viele Einsteiger verwechseln ein "i" am Wortanfang mit einem "hi", weshalb man hin und wieder auch Dinge wie "Hichigo" hört, was angeblich Erdbeere heißen soll.

"Imouto" heißt kleine Schwester, und "Himouto" habe ich noch nie gehört. Der einzige Begriff, der dem nahe kommt und grob etwas mit einem jungen Mädchen zu tun hat, ist "Hi no moto Oniko", was m. M. n. für eine Art Hassliebe zwischen jungen Chinesen und Japanern steht. :)

Disclaimer: Da du in deiner Frage nur Romaji verwendet hast, bleibe ich in meiner Antwort auch dabei. :)

...zur Antwort