Geh zum Tierarzt, auf dieser Seite ist sowieso jeder inkompetent in Sachen Medizin. Wende dich an einen experten, so schnell wie möglich!

untypisiertes Lambda Kalkül mit interpreter in LISP

Was ist nur falsch mit dir? Verwende einfach ein Shell Script so wie jeder andere normale Mensch auch. Meine Güte ihr Leute fuckt mich wirklich ab.

Ja es ist möglich ein Spiel wie flappybird in c++ zu entwickeln schon rein aus der Tatsache heraus dass C++ eine turingvollständige Sprache ist. Ich würde dir jedoch SFML statt diesem Proprietärem zeug empfehlen.

Ich kenne mich zwar nicht mit Xamarin aus aber aus meiner Erfahrung mit GUI Programmierung weiß ich, das du lieber einen Layoutmanager verwenden solltest der deine Widgets dann automatisch anordnet um deine Anwendung skalierbar zu machen. Hier wäre ein guter Anfang https://developer.xamarin.com/guides/xamarin-forms/user-interface/layouts/

WinForms ist schon seit Ewigkeiten deprecated und sollte deshalb nicht mehr verwendet werden. Ebenfalls erschließt sich mir nicht der Sinn dahinter ein Spiel in einem GUI Toolkit zu schreiben, es sei denn natürlich du meinst sowas wie PictureBox framebuffer software rendering.

Ich würde dir zum schreiben eines Tetris klons raten.

www.archlinux.org

Lies es lieber in ein std::array ein und verwende Iteratoren zum einlesen der Textdatei

sudo apt-get install gcc

Probiers mal aus

XCode und GameKit, ist jedoch mac only, was ja kein Problem sein sollte da du für die iOS Entwicklung sowieso einen mac brauchst.

fopen ist noch ein überbleibsel der C (nicht C++) standardbibliothek und ist daher nicht idiomatisches C++. Der idiomatische Weg eine Datei zum entweder lesen, oder schreiben zu öffnen sieht so aus:

#include <fstream>
int main(int argc, char **argv){
 //entweder du seperariest jeweils den input und output stream oder du verwendest den generellen fstream
 std::ofstream output("datei.txt");
 std::ifstream input("datei.txt"); //Eine möglichkeit eine datei zu öffnen
 input.open("datei.txt"); //zweite möglichkeit eine datei zu öffnen
 
 if(input.is_open()){
  ...
 }
 Ein und ausgabe erfolgt genauso wie mit std::cout und std::cin
 alternativ kann man ebenfalls zum zeilenweisen lesen einer datei std::getline() verwenden
 
 input.close(); //schließen nicht vergessen
 return 0;
}

Dies ist ganz einfach möglich mit der append() funktion.

std::string a = "Hallo ";
std::string b = "Welt!";
a.append(b); //a == "Hallo Welt!"

Also wenn man ganz semantisch sein will kann eine Funktion maximal einen Wert zurückgeben, jedoch gibt es ein paar "tricks" wie man dies umgehen kann. Wenn man eine Funktion haben will welche mehr als einen integralen datentypen zurück gibt und das jedes mal so kann man einfach ein struct erstellen welches die benötigten daten beinhaltet und dies dann zurückgeben. Hat man jedoch eine funktion welche entweder einen oder einen anderen, jedoch nicht beide gleichzeitig zurückgibt, so empfiehlt es sich ein union zu verwenden, da ein union in solchen Fällen speichereffizienter ist als ein struct da ein union immer nur maximal so viel speicher belegt wie sein größter member. Hat man jedoch eine Funktion welche alterierende Datentypen hat so kann man, entweder, falls man die boost bibliothek verwendet ein boost::any zurückgeben, oder falls man kein boost verwendet einen void *

//Beispiel 1
struct koordinaten {
 //struct ist in C++ der klasse ähnlich mit dem unterschied das alle member standardmäßig public sind
 //C++ unterstützt keine C-Style structs
 koordinaten(int x, int y) : _x(x), _y(y) {}
 int _x;
 int _y;
};
koordinaten x(int x, int y){
 koordinaten temp(x, y);
 return temp;
}
//Beispiel 2
union my_return_type {
 koordinaten k;
 int hoehe;
};
my_return_type x(int x, int y, int h){
 my_return_type temp;
 if(x == 0 && y == 0){
  temp.hoehe = h;
 }else {
  temp.k._x = x;
  temp.k._y = y;
 }
 return temp;
}
//Beispiel 3
void *x(int x){
 int a = 10;
 double b = 3.14;
 std::string c = "";
 switch(x){
  case 1:
   return (void *)&a;
  break;
  case 2:
   return (void *)&b;
  break;
 case 3:
  return (void *)&c;
 break;
}

Statt sleep() zu verwenden, was eine POSIX funktion ist und daher nicht auf allen Systemen verfügbar ist solltest du lieber folgendes equivalent benutzen welches aufgrund des C++11 standards auf jeden System verfügbar sein wird.

#include <thread>
#include <chrono>
int main(int argc, char **argv){
 std::this_thread::sleep_for(std::chrono::milliseconds(5000));
 return 0;
}

Dafür gibt es zwei Wege:

Der erste ist du tauscht den datentyp int von i durch void * aus.

Die zweite Möglichkeit ist die verwendung eines Template

//erste möglichkeit
class my_class {
 public:
  int my_int;
};
int x(void *i){
 my_class local_instance = *(my_class *)i;
 local_instance.i = ...
}
int main(int argc, char **argv){
 my_class main_instance;
 x((void *)&main_instance);
 return 0;
}
//zweite möglichkeit
class my_class {
 public:
  int my_int;
};
template<typename T> decltype(T) x(decltype(T) &i){
 i.my_int = ...
}
int main(int argc, char **argv){
 my_class main_instance;
 x<main_instance>(main_instance);
 return 0;
}

Ob es sich lohnt mit Xamarin und C# (oder VB.net oder F# und die vielzahl an "inoffiziellen" sprachen welche ebenfalls zu .NET bytecode kompillieren, beispielsweise Clojure über ClojureCLR) apps zu entwickeln kann man pauschal nicht sagen da dies von einer vielzahl an Faktoren abhängt. Einer dieser Faktoren ist beispielsweise der Kostenfaktor, der je nach der eigenen finanziellen Situation, ein ganz klarer Prohibitivfaktor sein kann. Wenn die Kosten nicht die Hauptrolle spielen so muss man ebenfalls in betracht ziehen, das man trotz Xamarin, es sei denn man verwendet Xamarin.Forms, dennoch platform spezifischen code schreiben muss, beispielsweise für die UI, und das für jede Platform für die man die App entwickelt. Selbst wenn man sich entschließt Xamarin.Forms zu verwenden sollte man, wenn man möchte das die eigene App anklang findet, dennoch platform spezifischen UI code schreiben da im Grunde jede relevante mobile platform ihre eigenen UI Paradigmen hat welche ein potenzieller Benutzer jener App von der App erwartet. Ein weiterer Faktor welcher für Xamarin und C# sprechen würde währe eine eventuelle "Sprachfäulle", d.H. Man will oder kann nicht die Zeit aufwenden um für jede Platform die Vorherrschende und "Vorgeschriebene" Sprache zu lernen. welche z.B. für IOS Objective-C und/oder Swift, für Android Java und für Windows Phone C# währe. Abhängig von den Platformen für die man entwickeln möchte ist die jedoch meiner Ansicht nach kein entscheidender Punkt da z.B. Java C# sehr ähnlich ist (was sich aus der Historie von C# ergiebt, welche, soweit ich mich recht erinnere, früher als eine proprietäre Java implementierung seitens Microsoft namens J++ begann, dann eingestellt und durch J++ ersetzt wurde, was dann durch C# 1.0 ersetzt wurde). Allgemein ist es nicht soo schwer eine andere Programmiersprache zu lernen wenn man schon eine beherrscht (und mit beherrschen meine ich nicht einfach nur können sondern vollständig alle features beherrschen zu können), vorrausgesetzt die Sprache die man lernen möchte verwendet das selbe Paradigma wie die Sprache mit der man schon vertraut ist, was bei Java und C# durch die gegenseitige verwendung des objektorientierten Paradigmas gegeben ist. Solltest du jedoch, sagen wir mal, clojure lernen wollen ohne mit dem funktionalem Paradigma vertraut zu sein wirst du erheblichere Probleme haben als jetzt mit C# Kentnissen Java zu lernen da dies im Grunde, jedenfalls auf einem idiologischem Niveau, im Grunde nur eine Syntax transformation ist. Glücklicherweise sind alle prävalenten Sprachen welche von den relevanten mobilen Platformen verwendet werde Objektorientiert was bedeutet das man sein Wissen über Objektorientierung größtenteils 1:1 anwenden kann was einen Umstieg auf diese Sprache immens erleichtert, ja fast schon trivial macht. Meiner Ansicht nach ist die größte Hürde beim schreiben von cross-platform apps jedoch nicht die sprachbarriere sondern das erlenen und behersschen der jeweiligen APIs. Eine Sprache ist schnell gelernt, manchmal in einer kurzen Zeit schon gemeistert aber das lernen der jeweiligen APIs dauert im Vergleich dazu ewigkeiten. Und hier komme ich nun zum springenden Punkt: Xamarin wird dir, meines Wissens nach, das erlenen der platform spezifischen APIs nicht ersparen weshalb ich dir definitiv zu nativen apps rate. Der einzige positive Aspekt welchen ich Xamarin abgewinnen kann ist das man die core-logic in einer einzigen Sprache auf allen Platformen verwenden kann, jedoch ist dies auch gegeben wenn man die core-logic in C++ schreibt welches kostenlos auf allen Platformen zur verfügung steht

sleep ist eine POSIX-funktion, d.H. sie ist standardmäßig nicht auf Windows systemen implementiert. Ich gehe mal davon aus das du einen einigermaßen aktuellen C++ compiler verwendest welcher C++11 unterstützt weshalb ich dir zu std::this_thread::sleep_for() rate: Dafür musst du den thread header einbinden

#include <thread>
#include <chrono>
int main(int argc, char **argv){
 std::this_thread::sleep_for(std::chrono::seconds(5));
 ODER
 std::this_thread::sleep_for(std::chrono::milliseconds(5000));
 return 0;
}

Wenn du dich nur "ein Wenig" in C++ auskennst, wird das nicht ausreichen. Ich persöhnlich bin DirectX (Ich nehme mal an das du eigentlich Direct3D meinst da DirectX weit mehr als nur Direct3D umfasst) nicht mächtig, jedoch kenne ich mich gut mit Grafikprogrammierung unter OpenGL und einem selbstgeschriebenem Softwarerenderer via GDI+ und Framebuffer unter Linux aus. Ich kann dir aus Erfahrung heraus garantieren das wenn du der WINAPI nicht mächtig bist und dich nicht mit den integranten details der C (nicht zwingend C++) programmiersprache bestens auskennst du mit sicherheit scheitern wirst. Direct3D zählt mit den zu abstand schwierigstens APIs welche es gibt. Dazu kommt noch, das die Spieleprogrammierung, zumindestens in 3D, weit mehr und vorallem kompliziertere Mathematik erfordert als das was man in der Schule lernt (z.B. Dynamic Lights via einem raycasting ähnlichem verfahren). 2D währe noch mit der Mathematik, welche man in einem Gymnasium lernt, machbar. 2D und 3D sind nicht inhärent so verschieden wie sie auf den ersten blick erscheinen, zumindestens in der implementation nicht da, wenn man 2D in einer 3D engine machen will man einfach eine der Vektorkomponenten (meistens die depth-komponente) einfach konstant macht. Bevor du dich an Direct3D wagst, solltest erstmal C und C++ und die WINAPI erstmal nahe zu perfekt beherrschen bevor du dich an DirectX wagst. Ich würde dir statt eines Buches einfach die Direct3D Dokumentation im MSDN empfehlen, die reicht aus. Statt Direct3D würde ich dir jedoch zu OpenGL raten da OpenGL (zumindestens modernes OpenGL ohne die fixed function pipeline) meiner Meinung nach nicht nur einfacher, sondern auch Leistungstärker ist (siehe Compute Shaders) als Direct3D. Ebenfalls ist OpenGL portabler als Direct3D und läuft auf allen relevanten Platformen (Windows, Linux, Mac, IOS, Android, etc...). Einen kleinen einblick in die OpenGL programmierung erhällst du hier: https://open.gl/

Um ehrlich zu sein solltest du es mit der Spieleentwicklung sein lassen wenn du der Meinung bist, dass du dazu ein Buch benötigst. Dies hat den Grund das Leute welche ein Buch benötigen meist (nicht immer, aber meist) weder die Grundlagen der Sprache beherrschen noch die Notwendigen Mathematischen kenntnisse besitzen welche die Entwicklung eines Spiels erfordert.

Im normalfall nicht, es sei denn du verwendest C++/CLI