Valerio

Es ist mir allerdings nicht ganz klar, was Du mit "statisch" und "dynamisch" in dem Zusammenhang genau meinst.

Momentan wird halt nur nach 2 aufeinanderfolgenden Buchstaben gesucht. Wenn ich jetzt z.B. das oben gepostete C-Programm so abänder, dass ich anstatt nach "ll", nach "Hallo" suchen möchte, so würde nur nach "Ha" gesucht werden.

Das war jetzt glaub ich etwas viel aufeinmal.. hab's nich so ganz verstanden, tut mir leid

Sollen für ein Hochschulpraktikum ein Programm in ARM Assembler entwickeln, welches in einem vorgegebenem String einen String sucht und am Ende ausgibt wie viele "Matches" stattgefunden haben.

int searchStringInString(char*, char*);


int main (void)

{

	int Anzahl;

	char* Text="hallo Alles klar?";

	char* Suchstring="ll";

	char* Leerstring="";


	Anzahl = searchStringInString(Text, Suchstring);

	Anzahl = searchStringInString(Text, Leerstring);	

	Anzahl = searchStringInString(Leerstring, Suchstring);

	Anzahl = searchStringInString(Leerstring, Leerstring);

// Aufrufe funktionieren auch so..

	Anzahl = searchStringInString("aabaabaab", "ab");


	return 0;

}[/PHP]

An der "searchStringInString" würde er anschließend in mein Assembler Programm springen, das momentan so aussieht:

Momentan gehe ich so vor:

Ich vergleiche immer 1 Byte (1 Buchstaben - momentan das "L") so lange, bis er einmal fündig geworden ist und springe anschließend zu "Match", wo das nächste Byte auf Gleichheit vergleichen wird. Wenn es ebenfalls gleich ist, wurde 1 mal gematched ("LL" gefunden). Mein Problem momentan? Es ist einfach verdammt statisch.

Hätte jemand evtl eine Idee, wie ich das ganze Dynamisch halten könnte?

Danke im voraus!

MfG

Valerio

Hat sich erledigt.. hab es jetzt hinbekommen =)

Danke dir @Klotzkopp

Bekomm's einfach nicht hin.. hab jetzt mehrere Varianten ausgetestet, bei den meisten kam es zu Heap-Fehlern und bei meiner aktuellen liegt das selbe Problem vor, wie eben. Kopiert werden die Objekte auch nicht.

void Manager::fractions_push_back(Fraction 

{

	 //cArray[c_size] = b;

	 //++c_size;                                  // umdrehen?


	if (mng.fractions_size() >= mng.fractionsCapacity)

	{

		allocateMemory();

		pfractions = new Fraction[fractionsCapacity];

	}


	pfractions[c_size++] = b;

}



void Manager::allocateMemory()

{

	 if (pfractions == 0)

		 fractionsCapacity = 1;

	 else

	 {


		 Fraction* pfractionsCopy = pfractions;

		 fractionsCapacity = fractionsCapacity*2;

		 pfractionsCopy = new Fraction[fractionsCapacity];

		 for (int n=0; n<c_size;n++)

		 {

		      pfractions[n] = pfractionsCopy[n];

	     }


		 delete[] pfractionsCopy;

	 }

}


[/PHP]

• Was tut fractions_push_back?
  
• Die Regel der großen 3: Wenn du einen dieser drei brauchst: Copy-Konstruktor, Copy-Zuweisungsoperator, Destruktor, dann brauchst du alle. Deine Fraction-Klasse braucht keinen dieser drei, somit auch keinen Copy-Konstruktor. Der vom Compiler automatisch generierte tut "das Richtige".
  
• Anstatt im Konstruktor-Rumpf die Member zuzuweisen, benutz Initialisierungslisten.

Das kommt auf die Objekte an. Wenn es POD-Typen sind, kannst du memcpy benutzen. Im allgemeinen Fall nimmst du einfach eine Schleife oder std::copy.

Fractions_push_back soll jeden zufällig erzeugten Bruch an die letzte Stelle des Arrays schieben.

Den Copy-Konstruktor sollten wir im Rahmen eines anderen Praktikums erstellen.

Das mit den Initialisierungslisten kann ich so nicht machen, da wir nur das verwenden dürfen, was in den Vorlesungen durchgenommen wurde. Da achtet der Prof in den Praktika auch ziemlich streng drauf..

Entschuldige wegen dem Doppelpost, hab aber mal ein paar Bilder von meinem momentan Fehler gemacht, damit wird es vielleicht etwas klarer.

Das 1. Bild zeigt den zufällig erzeugten Bruch

Numberofobjects einfach ignorieren =)

Bild1

Das 2. Bild zeigt das, was in pfractions steht, nachdem "geschrieben" wurde.

Bild2

Und das 3. zeigt eine Ausgabe

Bild3

Hier mal der Teil, in dem das zufällige Fraction Objekt erzeugt wird.

void Manager::createRndFraction()

{


   /* mng.clear();*/


	int MAX_N=0;

    int anzahlBrueche;


	while(true){

	    try {

	    MAX_N = get_int("Eingabe MAX_N: ");

	    anzahlBrueche = get_int("Anzahl: ");

	    }

        catch(std::runtime_error &msg){

		     std::cerr << msg.what() << std::endl;

		     std::cin.clear(); std::cin.sync();

		     continue;	 

	         }		

	    break;		   


	}


	std::cout << std::endl;


	mng.rnd_.MIN_ = -(MAX_N-1);

	mng.rnd_.MAX_ = MAX_N-1;



	int n=0;

	    while (n++<anzahlBrueche)

			{

		      Fraction r(mng.rnd_.get(), mng.rnd_.get());

		      mng.fractions_push_back(r);

		    }


}

[/PHP]

Die zugehörige Get-Funktion:

Und ein Teil der Fraction-Klasse + Konstruktor/Copy-Konstruktor:

class Fraction

{

private:

	int zaehler_;

	int nenner_;

public:

	Fraction(int zaehler_=0, int nenner_=1); //constructor

	Fraction(const Fraction &original);  //copy-constructor



Fraction::Fraction(int zaehler, int nenner)

{

	     zaehler_ = zaehler;

		 nenner_ = nenner;

		 //numberOfObjects_++;



		 cancelDown();

		 adjustSign();

}



Fraction::Fraction(const Fraction &original)

{

	zaehler_ = original.zaehler_;

	nenner_ = original.nenner_;

	//numberOfObjects_++;

}

[/PHP]

Das mit dem Kopieren der Werte habe ich noch nicht ganz verstanden.

Also erstmal eine Kopie meines aktuellen Zeigers anlegen

Ich nehme an, dass hier einfach nur der Umgang mit Arrays geübt werden soll. Für so etwas nimmt man in C++ normalerweise std::vector.

So ist es

Hab's jetzt mal selbst etwas versucht, funktioniert jetzt zwar einigermaßen, aber kleine Fehler sind noch drin.

Und zwar wird der Vektor ziemlich oft mit den Standartwerten des Konstruktors der Klasse Fraction gefüllt, sprich mit Zähler=0 und Nenner=1, obwohl der zufällig generierte Bruch anders aussieht. Hab das auch mit Einzelschritten im Debugger durchlaufen lassen, bin aber nicht fündig geworden.

Hier mal der aktuelle Quelltext

Header

class Manager

{

private:


	 RandomFraction rnd_;

	 Statistic stat_;

	 std::vector<Fraction> vec_;


	 //enum {MAX=1000};

	 //Fraction cArray[MAX];

	 Fraction *pfractions;

	 int fractionsCapacity;

	 int c_size;

public:

    friend class Fraction;


	Manager(int c_size=0, int fractionsCapacity=0, Fraction *pfractions=NULL);

	~Manager(void);



	void fractions_push_back(Fraction);

	int fractions_size() const;

	int &operator[](int);

	void erase(int);

	void clear();

	void allocateMemory();[/PHP]

[b]CPP[/b]

[PHP]Manager mng;

Manager::Manager(int c_size, int fractionsCapacity, Fraction *pfractions)
{
/* for ( int index=0 ; index<MAX ; index++ )
cArray[index] = 0;*/


this->fractionsCapacity=fractionsCapacity;

this->c_size = c_size;
}


void Manager::fractions_push_back(Fraction
{
//cArray[c_size] = b;
//++c_size;

if (mng.fractions_size() >= mng.fractionsCapacity)
{
allocateMemory();
pfractions = new Fraction[mng.fractionsCapacity];
pfractions[c_size++] = b;
}
else
pfractions[c_size++] = b;
}


int Manager::fractions_size() const
{
return c_size;
}


void Manager::allocateMemory()
{
if (pfractions == 0)
fractionsCapacity = 1;
else
fractionsCapacity = fractionsCapacity*2;
}

Was jetzt noch fehlt ist das Kopieren der Werte und das löschen des alten Speichers. Habe momentan noch keine Idee wie ich da am besten rangehen kann.

Hallo an alle!

Studiere im 1. Semester Informatik an einer FH und wir haben jetzt die 5. Praktikumsaufgabe in Programmieren gestellt bekommen, so ganz blick ich da aber nicht durch.

Es geht um folgendes:

Wir haben uns im Laufe der Praktika ein Programm gebastelt, welches Brüche einliest, ausgibt, berechnet und was auch immer mit diesen anstellt.

Das 5. Praktikum sieht jetzt voraus, dass wir unser aus dem 4. Praktikum erarbeiteten Vektor, das mit zufälligen Brüchen gefüllt wird durch ein C-Array ersetzen.

Das ganze soll natürlich dynamisch gehalten werden. Dazu folgender Auszug aus der Aufgabenstellung:

Teil B: Dynamische Speicherverwaltung

Stellen Sie nun Ihr Programm aus Teil A um auf dynamische Speicherverwaltung. Die Größe des verwendeten CArrays

soll sich nun dem Bedarf anpassen:

1. Unmittelbar nach dem Start der Anwendung gibt es noch gar kein C-Array sondern lediglich einen Zeiger

(Name: pfractions) der mit null initialisiert ist.

2. Jedes Mal, wenn mittels fractions_push_back ein Bruch hinzugefügt wird, soll fractions_push_back

prüfen, ob noch mindestens ein Speicherplatz für ein Bruchobjekt zur Verfügung steht. Falls nicht, soll

fractions_push_back, oder besser eine andere Memberfunktion, den verfügbaren Speicherplatz verdoppeln

und die bisher gespeicherten Elemente in den neuen Speicherplatz kopieren. Der alte Speicherplatz wird danach

nicht mehr benötigt. Für diese Funktionalität braucht man eine weitere Membervariable, die die Größe des

aktuell reservierten Speicherplatzes kennt (Name: fractionsCapacity).

Im Teil A sollte das Array statisch gehalten werden, nur als kleine Anmerkung.

Ich hab mir jetzt folgendes gedacht:

Erste Teilaufgabe von TeilB sagt ja, dass es noch gar kein Array geben soll, stattdessen halt einen Zeiger. Ich hab das jetzt so gemacht, korrigiert mich, falls es falsch ist.

Header-Datei

class Manager

{

private:


	 RandomFraction rnd_;

	 Statistic stat_;


	 //enum {MAX=1000};

	 //Fraction cArray[MAX];

	 Fraction *pfractions;

	 int fractionsCapacity;

	 int c_size;

public:

    friend class Fraction;


	Manager(int c_size=0, int fractionsCapacity=0);

	~Manager(void);


        ....   //einige weitere Memberfunktionen, hier aber überflüssig


	void fractions_push_back(Fraction);

	int fractions_size() const;

	int &operator[](int);

	void erase(int);

	void clear();

	void allocateMemory();


};

Manager mng;


Manager::Manager(int c_size, int fractionsCapacity)

{

	/*  for ( int index=0 ; index<MAX ; index++ )

           cArray[index] = 0;*/


	  pfractions = new Fraction(0);    [COLOR="red"]//kann das so stimmen?[/COLOR]

	  this->fractionsCapacity=fractionsCapacity;


	  this->c_size = c_size;

}



void Manager::fractions_push_back(Fraction 

{

	 //cArray[c_size] = b;

	 //++c_size;                                  


	if (mng.fractions_size() >= mng.fractionsCapacity)

	{

		allocateMemory();

		pfractions[c_size++] = b;       [COLOR="red"]//  c_size an dieser stelle richtig?[/COLOR]

	}

}



int Manager::fractions_size() const

{

	return c_size;

}



void Manager::allocateMemory()

{

	 if (pfractions == 0)

		 fractionsCapacity = 1;

	 else

		 fractionsCapacity = fractionsCapacity*2;

}[/code]

Gedacht hab ich mir das ganze so:

Jedes mal wenn ein Objekt mittels fractions_push_back ins Array geschoben werden soll, soll erstmal geprüft werden, ob schon Speicherplatz vorhanden ist. Wenn nicht, dann soll Speicherplatz der Größe 1 angelegt werden. Wenn schon Speicherplatz vorhanden ist, die Kapazität des Arrays aber überschritten wurde, soll der vorhandene Speicherplatz verdoppelt, die vorhandenen Werte des alten Speicherplatzes in den neuen kopiert und der alte Speicherplatz anschließend gelöscht werden.

So müsste das doch dynamisch funktionieren?

Das Problem ist jetzt die Realisierung.. hab bisher nie mit Zeigern gearbeitet und bräuchte deshalb etwas Unterstützung.

Danke im voraus!

MfG

Valerio

Sorry, weiß gerade nicht, worauf du hinaus willst

Erwischt

Meine Stärken liegen ehrlich woanders... mich verwirrt diese Fülle von Gesetzen, die es zu beachten gilt und wann genau welches Gesetz zum Einsatz kommt. Andere Umformungen kann ich dir so spontan keine nennen.

Zur Aufgabe:

-(-(-A^ ^ -(A^-) -> Was ist jetzt mit den ANDS in den Klammern zwischen A und B? Da ich sie ja doppelt negiert habe, bleiben sie ja eigentlich gleich, damit hätte ich aber kein NAND. Wie eben nur die Negation über dem AND auflösen?

OK, verstehe was du meinst. Na, dann weiß ich ja schon mal, dass mein Ansatz völliger Schwachsinn war.

Wie dem auch sei.. also so wie ich das jetzt verstanden hab, muss ich einfach nur schauen, dass ich aus dem ^ und v ein -^ mache, richtig?

Das heißt, wenn ich (-A^ v (A^- doppelt negiere und 1 Negation über dem v aufhebe, hätte ich doch 1 NAND, oder?

(-A^ v (A^- = -(-(-AB) v -(A-)

Kann das stimmen?

Hat keiner ne Ahnung?

Ist wirklich dringend... morgen hab ich ein FH-bezogenes Praktikum und bis dahin muss das sitzen^^

Hallo an alle!

Ich hoffe mir kann jemand von euch bei meinem kleinen Problemchen mit Rat und Tat zur Seite stehen.. und zwar geht es um folgendes:

Ich soll mir eine Wahrheitstabelle jeweils für die XOR- und XNOR-Funktion erstellen und daraus die DNF und KNF bilden. Das habe ich soweit gemacht und kam zum diesem Ergebnis:

XOR

Ein - vorm Buchstaben = NICHT

DNF: (-A^ v (A^-

KNF: (AvB) ^ (-Av-

XNOR

DNF: (-A^- v (A^

KNF: (Av- ^ (-Av-

Soweit so gut, aber jetzt geht die Aufgabenstellung leider weiter.

Ich soll mir von der XOR-Funktion eine der beiden Darstellungen rauspicken und sie algebraisch so umformen, dass ich die Schaltung ausschließlich mit NAND-Gattern effizient realisieren kann. Das gleiche bei der XNOR-Funktion, nur dass es hierbei ein NOR-Gatter werden soll.

Ich steh total auf dem Schlauch...

Danke im voraus!

MfG

----Nachtrag---

Habe gerade etwas herumprobiert und jetzt stellt sich eine weitere Frage auf.

Darf man bei dieser Art der Rechnung die Klammern ausmultiplizieren, wie als hätte man eine "Binomische Formel"?

Dann würde meine Rechnung bei der DNF der XOR-Funktion nämlich so aussehen:

(-A^ v (A^- = (-A^A) v (-A^- v (B^A) v (B^-

Die erste und letzte Klammer würden sich wegkürzen und übrig bleibt somit

(-A^- v (A^

Und das wär ja eigentlich ein NAND oder verbunden mit einem NAND NICHT.

Genau so stell ich mir eine gute Erklärung vor. Danke an dich unbenannt, hab's jetzt verstanden.

Hallo liebe Fachinformatiker! ;-D

Aufgrund eines geplanten Informatikstudiums bin ich gerade dabei mir C in Eigenregie, mithilfe C-HowTo - Programmieren in C, beizubringen. Bisher hat das auch ganz gut geklappt, nur das jetzige Kapitel verwirrt mich doch leicht und deshalb hoffe ich, dass mir jemand von euch helfen könnte.

Worum es geht steht ja bereits im Titel - Zeigerarithmetik.

Und zwar steht im Tutorial der besagten Seite folgender Code:

// Array und Spaltengrenze setzen

int brett[8][8]={ 0 }, Y_Max=8;


// Startposition

int *posStart = &brett[0][0];


// Testwert setzen

brett[2][4] = 2;


// Beschaffung Testwert mit Zeigerarithmetik

int *pos;

pos = posStart + (2 * Y_Max) + 4;


printf("%d\n", *pos );

2

Und dazu diese Erklärung:

Die entscheidende Programmzeile ist die, in der der Positionszeiger pos gesetzt wird. Seine Basis ist die Startadresse des Arrays. Benötigt wird der Wert 4 in Spalte 2, Index [2][4]. Um dorthin zu kommen, müssen wir uns spaltenweise vorarbeiten. Also setzen wir den Zeiger auf das erste Element in Spalte 2. Eine Spalte hat 8 Elemente, also müssen wir den Zeiger 2 * 8 Elemente weiterrutschen. Zum Schluss addieren wir noch die 4, um in die vierte Zeile zu springen.

Anfangs eigentlich ziemlich plausibel, zumindest bis zum Punkt, in dem der Testwert beschaffen wird. Ab da versteh ich irgendwie garnichts mehr.

In der Erklärung steht ja, dass der Wert 4 benötigt wird. Warum?

Und das ganze auch in der 2. Spalte des Arrays... das verwirrt mich gerade leicht. Ich dachte die erste Zahl der Deklaration eines zweidimensionalen Arrays bezieht sich auf die Zeilen -> index[2][4].

Kurzum... ich steh ziemlich auf dem Schlauch und wär wirklich froh, wenns mir jemand anfängerfreundlich erklären könnte.

Danke im voraus!

Mfg