Coden lernen

Am Ende ist das wichtigste, dass du daran Spaß hast und nicht aufhörst. Keiner zwingt dich ein Buch durchzuarbeiten, auch wenn es wahrscheinlich die effektivste Methode ist.
Die Vorgehensweise soll jeder selbst entscheiden. Es ist auch ein Unterschied, ob du einfach nur Mods/Clients für Teeworlds machen willst oder richtig programmieren willst.

Hast du überhaupt schon einen Text-Editor mit Compiler (um den Programmcode auszuführen)? Wenn du nämlich wirklich bei 0 bist würde Ich glaub Ich sogar Videos anfangs bevorzugen. (Kanal: thenewboston wenn du englisch verstehst)

falls nicht: damit du dir das googlen sparen kannst, hier sind die am weitestesten verbreiteten IDEs:
für java intellij IDEA oder eclipse, für c / c++ ms visual studio

Für Java ist Netbeans auch noch ziemlich bekannt, dass kann man (wie auch Eclipse) auch für C++ und einiges weitere benutzen.

IDE brauchst du theoretisch nicht, schadet nicht das alles mal von Hand mit den entsprechenden Programmen zu machen ::P:
Zumd. um mal ganz grob zu verstehen, was die IDE da letztendlich macht.

Der beste Editor für so ziemlich alle Sprachen die es gibt ist mMn ja immer noch 'vim', aber den wirst du weder kennen, noch ohne Einarbeitung bedienen können und vermutlich gibts den für Windows auch nur mit GUI..

Habe so ein c++ buch, ist aber mal verdamt komplex .. da verliert man sofort die lust daran

Das liegt nicht am Buch, sondern an der Sprache :))
Welches Buch benutzt du denn?

C++ ist für den Anfang sehr schwer, auch wenn es sich lohnt (oder lohnen kann).
Wenn du einen einfacheren Einstieg willst, solltest du evtl. mit Java oder Python anfangen.

Für Teeworlds wird dir das natürlich wenig helfen ::P:

Für Teeworlds muss man kein C++ können und umgekehrt, bestes beispiel bin da ich xD

Src runterladen, anstarren, variablen verändern. So fängt jeder an. Isso.

Miku schrieb:

Nur das Problem jetzt ist, da lernt man mit Deutsch das Coden also nicht auf Englisch, wär das für ein anfang doof? Immerhin könnte ich ja vllt mal auf Englisch rüber gehen oder wird das zu schwer?

wie auf deutsch? auch wenn es eher ne schlechte angewohnheit ist, kannst du deine variablen, funktionen etc ruhig mit deutschen namen versehen. alles andere ist in jeder sprache genau gleich. oder ich verstehe deine frage nicht.

EDIT: also ich habs mir ein bisschen angeschaut, er hat halt einfach alle klassen und so mit deutschen namen versehen. das ist kein problem, das kann man machen, wie man möchte. (wie gesagt, englisch ist immer besser, weil die ganze welt deinen code versteht, aber am anfang sollte deutsch völlig reichen)

Also du kannst deine variablen auch crytopgraphieren, funktionieren tut ein programm dann immernoch ^^ es sollte doch keine Herausforderung sein das ganze von deutsch auf Englisch zu übertragen ^^

Am Anfang ist es relativ egal ob du Deutsch oder Englisch programmierst. Du gewöhnst dich halt nur daran und wenn du später "schön" programmieren möchtest, müsstest du es dir erst noch abgewöhnen.

wenn mans dann kann, kann man irgendwann mal sowas komplett sinnloses machen xD
so ähnlich wie events in javascript/node.js

[cpp]
#include <chrono>
#include <iostream>
#include <thread>
#include <future>
#include <type_traits>

template<typename Func, typename... Args, typename LambdaReturn = typename mlk::lambda_info<Func>::return_type>
auto doSmthInTheFuture(Func&& f, Args&&... args) {
std::packaged_task<LambdaReturn(Args...)> task{f};
std::future<LambdaReturn> future{task.get_future()};
std::thread(std::move(task), std::forward<Args>(args)...).detach();
return future;
}

template<int i, int max>
typename std::enable_if<(i >= max), void>::type createTask() {
/* Do nothing; end call loop */
}

template<int i, int max>
typename std::enable_if<(i < max), void>::type createTask() {
doSmthInTheFuture([](int sink) {
std::this_thread::sleep_for(std::chrono::milliseconds(500));
std::cout << "This is task number: " << sink << std::endl;
}, i).wait();

createTask<i + 1, max>();
}

template<int numTasks>
void taskFactory() {
createTask<0, numTasks>();
}

int main() {
taskFactory<5>();

// create a task in the future
auto future = doSmthInTheFuture([](int i) {
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
std::cout << "I come from the future. Meaning of life: " << i << std::endl;
return i * 2;
}, 42 /* arguments for the task */);

std::cout << "Waiting for the future..." << std::endl;
future.wait(); // wait for the future to finish its task
std::cout << "The future returned: " << future.get() << std::endl; // get the future return


// Output:
// This is task number: 0
// This is task number: 1
// This is task number: 2
// This is task number: 3
// This is task number: 4
// Waiting for the future...
// I come from the future. Meaning of life: 42
// The future returned: 84
}
[/cpp]

das kann ich auch so xD schonmal den gamecore in teeworlds geschrottet?

Für Teeworlds muss man kein C++ können und umgekehrt, bestes beispiel bin da ich xD

Naja den Code schrotten und solange alles austauschen bis die Munition einer Waffe verändert wurde etc. würde ich jz. nicht als coden bezeichnen, von daher kann C++ schonmal nicht schaden ::P:
Man will ja auch zumd. irgendwas davon verstehen..

Nur das Problem jetzt ist, da lernt man mit Deutsch das Coden also nicht
auf Englisch, wär das für ein anfang doof? Immerhin könnte ich ja vllt
mal auf Englisch rüber gehen oder wird das zu schwer?

Das ist eigtl. wirklich vollkommen egal.
Kannst die Klassen oder was auch immer in dem Kurs da geschrieben wird (wer weiß ob das OOP ist ^^) ja einfach Englisch benennen.

Also du kannst deine variablen auch crytopgraphieren, funktionieren tut ein programm dann immernoch ^^

Kommt auf die Sprache an ::P:
Gibt auch Sprachen die die Benennung stärker einschränken.



OT: @ Malek
Wieso tut man sich Template-Programmierung in C++ an? :S:

besser, schneller, schöner, moderner, die zukunft von c++, isocpp.org/blog/2014/08/we-have-cpp14
bsp. kürzerer code:
[cpp]
class SomeType {
public:
void handle() {

}
};

template<typename AnyType>
void doStuffT(AnyType& obj) {
obj.handle();
}

int main() {
SomeType obj;
doStuffT(obj);
}

[/cpp]

als:

[cpp]
class Base {
public:
virtual void handle() = 0;
};

class Derived final : public Base {
public:
virtual void handle() override {

}
};

void doStuff(Base* b) {
b->handle();
}

int main() {
Derived d;
doStuff(&d);
}
[/cpp]

200 zu 250 assembly zeilen
300 zu 600 nanosekunden
sind kleinigkeiten die sich zb bei einem spiel extrem auswirken können ~

[cpp]
class Something
{
void handle{ }
}

void doStuff(T) (T obj)
{
obj.handle(); // per templateConstraint könnte man das ganze noch compile-time sicher machen, wäre dann so: void doStuff(T) (T obj) if ( T.isHandler)
}

void main()
{
auto obj = new Something();
obj.doStuff();
}
[/cpp]

Nochmal: Warum Templateprogrammierung in C++ ?
(Code ist btw in D, nicht C++)

dlang.org/garbage.html

setzen, nächster bitte :D
c++ ist einfach leistungsstärker als der ganze andere kram
Stroustrup: Why the 35-year-old C++ still dominates 'real' dev

Der Garbace Collector in D ist optional - wenn auch standardmäßig aktiviert.
Zwingt dich keiner dazu den zu benutzen, auch wenn es in mind. 95% der Fälle überhaupt kein Problem ist mit einem GC zu arbeiten.
Und für die 5% kann man den GC ausschalten und inline-asm schreiben.

Und Performancetechnisch wäre ich mir da nicht so sicher.
Facebook hat vor kurzem einen Precompiler (oder was ähnliches) von einem der D Hauptenwickler in D entwickeln lassen und ihre C++-Variante damit ersetzt.
Die D Variante arbeitet schneller, und ist aufgrund des schöneren Codes wesentlich leichter zu maintainen.

Außerdem ist D wie auch C++ komplett kompatibel zu C und man kann im Zweifelsfall direkt zu C interfacen wenn man das braucht.

Mal ganz abgesehen davon, dass leistungsstärke lang nicht überall das wichtigste ist, ist D oftmals verdammt nah an C/C++ speed dran.
Für viele Projekte ist ein einfach zu maintainendes Projekt oftmals sogar wichtiger, als eins, dass 0.5% schneller läuft als die Variante in einer anderen Sprache.