Welche Sprache lernen ?

GPC

STF-DIR schrieb:

Es stellt sich eigentlich nur die Frage ob C++/CLI oder C# ?
Welche dieser beiden ist denn eher für die Zukunft geeignet ?

Beide werden über kurz oder lang in der Versenkung verschwinden (bzw. es wird nur noch der vorhandene Codebestand gepflegt). So ist der Lauf der Dinge. Vllt. semmelt erst C++/CLI ab, vllt. auch C#. Vllt. beide gleichzeitig.
Wichtig ist nur, dass du

GPC schrieb:

das Programmieren an sich (==die Konzepte) verstanden hast. Die kannst du dann in einer Vielzahl von Sprachen anwenden.

Du wirst über kurz oder lang eh neue Sprachen lernen müssen, weil die derzeit aktuellen einfach nicht mehr so gefragt sind. Aber bis es soweit ist, gehen noch einige Jahre ins Land und deshalb ist Zukunftssicherheit ein Aspekt, der dir egal sein sollte. Bis dahin wirst du schon längst in andere Sprachen reingeschnuppert und deinen "Favoriten" gefunden haben.

STF-DIR

Hallo,

ok, also beide.

Hmm, muss also das Projekt entscheiden.
Ich habe in Delphi 7 ein Projekt welches
- ein bischen OGL
- Downloads von wetter ( Eine seite runterladen und parsen )
- verbindung zum MS FlightSim 2004 ( später soll auch FSX gehen )
- Flugpläne mit A* Algorythmus erstellen
- ... und ausdrucken.

kann.

Mit was fange ich also an ist die Frage.
Lernen werde ich wohl dann beide Sprachen. Aber womit fange ich an ?

Matthias

THX 1138

STF-DIR schrieb:

- ein bischen OGL

geht mit reinem C++

- Downloads von wetter ( Eine seite runterladen und parsen )

geht mit reinem C++

- verbindung zum MS FlightSim 2004 ( später soll auch FSX gehen )

weiss ich nicht

- Flugpläne mit A* Algorythmus erstellen

geht mit reinem C++

- ... und ausdrucken.

geht mit reinem C++

*mit reinem C++ und entsprechenden libs natürlich

STF-DIR

Hallo,

würde also heißen das ich mit C++ anfangen könnte.

Die verbindung mit dem FSX ist glaube ich laut MS für .NET ausgelegt. Weiß ich aber nicht genau.
Ich gehe aber mal davon aus das das ganze was, wie du schreibst, mit "einfachem C++ geht auch mit "Managed C++" also CLI geht oder sehe ich das falsch ?

Matthias

THX 1138

STF-DIR schrieb:

Hallo,

würde also heißen das ich mit C++ anfangen könnte.

Die verbindung mit dem FSX ist glaube ich laut MS für .NET ausgelegt. Weiß ich aber nicht genau.
Ich gehe aber mal davon aus das das ganze was, wie du schreibst, mit "einfachem C++ geht auch mit "Managed C++" also CLI geht oder sehe ich das falsch ?

Matthias

Natürlich, geht auch mit managed, geht auch mit C#. Ist ev auch einfacher, aber halt Geschmacksfrage. Und für native C++ gibts wohl noch mehr Bibliotheken und Frameworks, aber da kann ich mich täuschen..

STF-DIR

Hallo,

ok ich dank euch allen für die Hilfe.
Ich werd wohl mit C++ anfangen und schauen wie es geht.
Falls nicht mach ich mit C# weiter.

Also Danke euch
Matthias

Knuddlbaer

Ich würde zu C# raten.

Hier kannst Du (sofern Du reinschaust) die Beispiele in der MSDN leichter nutzen und kannst wesentlich mehr Informationen verarbeiten die bei Problemen angeboten werden. (Mehr Copy & Paste).

C++ empfiehlt sich nur, wenn man sich auch die nötige Zeit für die Grundlagen nehmen möchte.

Du kannst Dir auch durchaus mal VB.NET ansehen, man kann ja später die Objekte zwischen den .Net sprachen tauschen.

Der Voteil von VB wären sehr umfangreiche Dokumentation und weniger komplexe Regeln. (ALso eher was in richtung: Im Buch so abgebildet, da und da draufklicken und fertig).

STF-DIR

Hallo,

danke für die Antwort.
Ich hab mich entschlossen in aller Ruhe erst mal C++ ( nach neuen Buch ) zu lernen und dann ( wie du schon sagtest ) erst auf C# umsteigen. Später lerne ich dann .NET mit C#.

Trotzdem Danke nochmal für die Antwort.

Ich stell dir mal eben gleich hier noch ne kleine Frage ( hoffe das is ok ? )
Ich bin gerade bei Dynamischer Speicherverwaltung und soll hier ein kleines Beispiel schreiben. Geht auch so weit, nur ich versteh hier was nicht so ganz.

Also Aufgabe ist es ( und ich soll das als Übung auch so machen ) eine Klasse zu schreiben die ein dynaisches Int Feld verwaltet, also einen Array.
So weit so gut.
Konstruktor ist so das man die Größe ( Anzahl der Werte ) übergeben muss.
Das geht auch , kein Thema.

Nun kommts...ich soll eine Methode Add( int wert) schreiben die dem verwalteten Array ein Elemeent anhängt.

Ich hab das versucht so zu lösen:

void CIntFeld::Add(int wert)
{
	_g+=1;   // Anzahl der Werte um 1 erhöhen
	int *temp = new int[_g+1];  // Temporäres IntFeld der neuen Größe
	temp = feld;  // Werte aus altem intFeld dem TempIntFeld zuweisen
	temp[_g] = wert;  // Neuer Wert im letzten Feld speichern
         delete[](feld); // Altes Feld löschen
         int *feld = new int[_g]; // Feld wieder neu anlegen
         feld = temp; // Feld wird Temp zugewiesen
         delete[](temp); // Hier ist der Fehler ????
}

Ich weiß das das umständlich ist und einfacher geht, aber ich soll das hier laut der Übung eben mal so machen.
Problem ist nur das delete[](temp); einen Fehler verursacht ??

Ich glaub der Fehler liegt hier

temp = feld;

bin mir aber noch nicht sicher.

Matthias

Knuddlbaer

int *temp = new int[_g+1];  // Zeiger auf ein array von int speichern    
temp = feld;  // Den Zeiger wegwerfen und den von feld nehmen
temp[_g] = wert;  // In Feld[_g] ein Wert schreiben
delete[](feld); // Altes Feld löschen 
         int *feld = new int[_g]; // Zeiger auf array von int 
         feld = temp; // Zeiger wegwerfen und den von temp verwenden (bereits gelöschtes altes feld)
         delete[](temp); // Noch mal gelöschten Speicher löschen

Was Du jetzt mit dem Code bezweckst weiß ich nicht.
Du kannst native Arrays nicht mit = zuweisen, du weisst so die Zeiger zu.

STF-DIR

Hallo,

was das bezwecken soll ?
Frag mal Andr'e Willms, steht in dem Buch hier.
Das mit den Zeigern zuweisen hab ich jetzt nachgelsen. Ghet nicht. OK.

Aber ein Feld das mit

int * f = new int[5];

erzeugt wurde muss ich doch mit

delete[](f);

löschen können oder ?

Matthias

Knuddlbaer

Ja, aber lies doch mal die Kommentare die da stehen
bzw. schau mal in Deinem Buch nach was beim Zuweisen
der Zeiger passiert.

Hier mal die Kurzversion:

temp = feld;  // Werte aus altem intFeld dem TempIntFeld zuweisen
    delete[](feld); // Altes Feld löschen
    feld = temp; // Feld wird Temp zugewiesen
    delete[](temp); // Hier ist der

Du löschst den gleichen Zeiger zweimal.

In dem kurzen Codestück hast Du
2 x Memoryleaks
1 x Speicherzugriffsfehler
1 x Speicher doppelt löschen

eventuell komme noch 1 logischer Fehler hinzu:

_g+=1;
int *temp = new int[_g+1];

STF-DIR

Hallo,

ja, ich bin ja am lernen .. entschuldige das ich es noch nicht geschnallt habe

Hier ist der orginal code aus dem Buch :

*.h

#pragma once

class DynIntFeld {
  int *feld;
  int groesse;
  int kapazitaet;

public:
  DynIntFeld(): feld(new int[2]), groesse(0), kapazitaet(2)
  {}

  DynIntFeld(int g): groesse(g), kapazitaet(g) {
    feld = new int[groesse];
  }
  ~DynIntFeld() {
    delete[](feld);
  }

  void setWert(int pos, int wert) {
    feld[pos]=wert;
  }

  int getWert(int pos) const {
    return(feld[pos]);
  }

  int size() const {
    return(groesse);
  }

  int capacity() const {
    return(kapazitaet);
  }

  void add(int wert) {
    if(groesse>=kapazitaet) {
      int* nf=new int[kapazitaet*2];
      for(int i=0; i<groesse; ++i)
        nf[i]=feld[i];
      delete[](feld);
      feld=nf;
      kapazitaet*=2;
    }
    feld[groesse++]=wert;
  }

};

und

*.cpp

#include <iostream>
#include <vector>
#include "DynIntFeld.h"

using namespace std;

int main() {
  cout << "Wie viele Werte:";
  int x;
  cin >> x;
  DynIntFeld f;
  for(int i=0; i<x; ++i) {
    cout << "Wert " << i+1 << ":";
    int w;
    cin >> w;
    f.add(w);
  }

  for(int i=0; i<f.size(); ++i)
    cout << "Wert " << i+1 << ": " << f.getWert(i) << endl;

  cout << "Feldkapazitaet: " << f.capacity() << endl;

  system("pause");

}

Ich weiß auch nicht wirklich was er da mit der kapazität macht ??
Was ich nicht verstehe ist das laut deiner Aussage ( glaube ich ) das hier nicht richtig ist ?

feld=nf;

Ich denke das geht nicht ?

Sorry aber ich habs noch nicht verstanden.
Bei mir is es jetzt so :

void CIntFeld::Add(int wert)
{
	_g++;
	std::cout << "_g: " << _g << std::endl;

	int *temp = new int[_g];

	for(int x=0; x<=_g; x++)
		temp[x] = feld[x];

	feld[_g-1] = wert;

	//delete[](temp);
}

Das delete[](temp); verursacht aber einen Fehler und ich weiß nicht warum ?

Matthias

Knuddlbaer

Erkläre mal bei jeder Zeile Deine Gedanken warum Du es so gemacht hast und erläutere was Deiner Meinung nach passieren sollte.

STF-DIR

Habs gefunden ...sorry !!!

void CIntFeld::Add(int wert)
{
	_g++;
	std::cout << "_g: " << _g << std::endl;

	int *temp = new int[_g];

	for(int x=0; x<_g; x++)  // x<_g nicht x<=_g
		temp[x] = feld[x];

	feld[_g-1] = wert;

	delete[](temp);
}

Eben ein Denkfehler.

Trotzdem steht die frage was der da mit

feld=nf;

macht ?

Matthias

Knuddlbaer

Eine Zuweisung ?

Ich frag mich eher was Du mit temp machst, wenn Du es eh weg wirfst

STF-DIR

Hallo,

ich glaube ich habs jetzt kapiert.
Hab mal Kommentare geschrieben.
Könntest Du mich nochmal berichtiogen falls ich da was falsch verstanden habe ( immernoch )

main.cpp ( so wird das Objekt erzeugt, sind also 2 Elemente .. nur zur info )

CIntFeld *f = new CIntFeld(2);

	f->setWert(0,0);
	f->setWert(1,1);

void CIntFeld::Add(int wert)
{
	// Größe des Feldes um 1 erhöhen weil ein wert dazu kommt
	_g++;
	// Einen neuen Zeiger auf einen IntArray erstellen
	// Größe = _g ( also 3 nach dem ersten Aufruf von Add()
	int *temp = new int[_g];

	// Jedem Wert von Temp[x] wird der gleiche wert wie Feld zugewiesen
	// Schleife geht bis 2 !!
	for(int x=0; x<_g; x++)
		temp[x] = feld[x];

	// Hier wird der originale Zeiger auf Feld verworfen
	delete[](feld);
	// ..und hier haben wir wieder einen Zeiger namens Feld der
	// hier die Adresse von temp zugewiesen bekommt oder ?
	feld = temp;

	// Hier wird nur noch dem letzten Element der neue 
	// Wert zugewiesen
	feld[_g-1] = wert;
}

Ich hoffe das stimmt jetzt so ?

Matthias

Knuddlbaer

Ja, Du schreibst aber den neuen Wert in das vorletzte Feld des Arrays.

Unterstriche als Anfang einer Variable solltest Du vermeiden, wirf häufig von Implmentierungen des Compilers verwendet (lasst die Goldwaage stecken ;o) .

STF-DIR

Hallo,

ok, die mit Unterstrichen sind bei mir die als private deklarierten. War so ein Einfall

Trotzdem ( sorry sorry ) habe ich etwas nioch nicht ganz kapiert.
Warum kann ich denn am ende der procedure den temp Zeiger nicht löschen ?
Ich habe doch mit
feld = temp;
die Adresse von temp an feld zugewiesen oder versteh ich das falsch ?
feld und temp sind doch Zeiger und Zeiger speichern Adressen.
Dann müsste doch eigentlich temp nach der Methode unnütz sein oder ?
Warum kann ich den nicht löschen ?

delete[](temp);

geht zwar ohne Fehler aber dann sind die Werte von feld leer ??
Also in der main.cpp gibt

for(int x=0; x<=f->getSize()-1; x++)
	{
		cout << "nachher " << x << " : " << f->getWert(x) << endl;
	}

blödsinnige werte aus.

Sorry aber ich muss das genau verstehen sonst brauch ich nicht weiterlesen. Das bringt nix.

Danke für Dein Verständnis !!
Matthias

Knuddlbaer

Was heißt weiterlesen ? Mal vorne Anfangen meinst.

temp benötigst Du weil für das Vergrößern eines Arrays neuer speicher angelegt sein muss.

temp wird in Deinem geposteten Code nicht gelöscht.

Ohne aktuellen Code kann man Dir nix sagen.

STF-DIR

Hallo,

nein, ich meine schon WEITERLESEN, denn das ist ja das erste Kapitel wo es sich um sowas dreht.
Sorry, aber wenn Du auch mal lesen würdest :

.
.
Dann müsste doch eigentlich temp nach der Methode unnütz sein oder ?
Warum kann ich den nicht löschen ?

delete[](temp);

geht zwar ohne Fehler aber dann sind die Werte von feld leer ??
Also in der main.cpp gibt
.
.

Dann würden es nicht immer soooo viele Postings werden.
Meckern kann jeder, erklären leider nicht

Matthias