Aufgabe 3.14:

Lesen Sie Text in einen Vektor ein und speichern Sie jedes Wort der Eingabe als Vektorelemenet. Verwandeln Sie die Wörter in Großbuchstaben. Geben Sie die umgewandelten Elemente in Zeilen zu je acht Wörtern aus.

#include <iostream>
#include <string>
#include <vector>

using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;

int main()
{
    string temp;
    string temp_modify;
    vector<string> words;

    while(getline(cin,temp) and temp != "~") //"~" Bedingung zum Beenden von Eingabe
    {
        for(string::size_type i=0; i<temp.size(); ++i)
        {
            temp_modify += toupper(temp[i]);
        }
        words.push_back(temp_modify);
        temp_modify = "";
    }

    for(vector<string>::size_type i=0; i<words.size(); ++i)
    {
        for(vector<string>::size_type j=0; j<8; ++j) //8 Wörter pro Zeile
        {
            if( (i+j) > (words.size() - 1) ) break; //Schutz vor Pufferüberlauf
            cout << words[i+j] << " ";
        }
        i += 7;
        cout << endl;
    }

    return 0;
}

Eure Meinung? Hättet ihr dass anderst gelöst? Kann man etwas verbessern?

MfG
Stromberg

Eure Meinung?

Löst die Aufgabe, ist also in Ordnung.
Manches hätte man einfacher oder eleganter lösen können, aber es ist nicht sicher, ob das im Kontext dieser Aufgabe bereits bekannt oder gewünscht war.

Stromberg schrieb:

Hättet ihr dass anderst gelöst?

Das Wort "anderst" gibt es nicht.

int main() 
{ 
    std::vector<std::string> vs = std::vector<std::string>(std::istream_iterator<std::string>(std::cin), std::istream_iterator<std::string>()); 
	for( size_t i = 0; i < vs.size(); ++i )
	{
	    std::transform(vs[i].begin(), vs[i].end(), vs[i].begin(), static_cast<int(*)(int)>(std::toupper));
	}
	for( size_t i = 0; i < vs.size(); ++i )
	{
		std::cout << vs[i] << ' ';
		if(i%8 == 7)
		{
			std::cout << std::endl;
		}
	}
}

Man könnte auch mit transform sofort auf cout ausgeben. Dann sind allerdings die Strings im Vector nicht umgewandelt, sondern nur die Ausgabe.

Stromberg schrieb:

Kann man etwas verbessern?

Anstatt temp_modify immer wieder zu leeren, könntest du es einfach erst in der Schleife deklarieren. Eigentlich könntest du auf temp_modify komplett verzichten und statt dessen temp "in-place" umwandeln.

Und der Vergleich (i+j) > (words.size() - 1) ist etwas holprig, warum nicht einfach (i+j) => words.size()?

wahrscheinlich nur eine persönliche Ästhetiksache, aber ich finde den "Matrixzugriff" auf words einerseits unschön/überflüssig und andererseits empfinde ich ihn als leichter lesbar mit

...
    for(vector<string>::size_type i=0; i<spaltenAnzahl; ++i)    {
        for(vector<string>::size_type j=0; j<zeilenAnzahl; ++j) {
...
            cout << words[i*spaltenLaenge + j] << " ";
...

als mit dem break/Index+=7/...

Aber das hier:

Stromberg schrieb:

...

using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;
...
string::size_type
...
vector<string>::size_type

...

finde ich ausgesprochen schönen Stil (wenn auch für ein kleines Beispiel etwas oversized).

Gruß,

Simon2.

Lesen Sie eine Reihe von Intergerzahlen in einen Vektor ein. Berechnen Sie die Summe von jeweils zwei aufeinander folgenden Elementen und geben Sie sie aus. Wenn die Anzahl der Elemente ungerade ist, teilen Sie dies dem Benutzer mit und geben den letzten Wert ohne Addition aus. [MIT ITERATOREN LÖSEN, NICHT MIT INDIZES!]

Hier der Code:

#include <iostream>
#include <string>
#include <vector>

using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;

int main()
{
    vector<int>::size_type elements;
    vector<int> values;
    cout << "Wieviele Elemente? ";
    cin >> elements;

    for(vector<int>::size_type j = 1; j <= elements; ++j)
    {
        int temp = 0;
        cin >> temp;
        values.push_back(temp);
    }

    cout << endl;

    int temp = 0;
    short counter = 0;

    for(vector<int>::iterator iter = values.begin(); iter != values.end(); ++iter)
    {
        temp += *iter;
        ++counter;
        if(counter == 2)
        {
            cout << temp << endl;
            temp = 0;
            counter = 0;
        }
    }

    if( (elements % 2) != 0)
    {
        vector<int>::iterator iter = values.end();
        --iter;
        cout << "Anzahl der Elemente ist ungerade." << endl;
        cout << *iter << endl;
    }

    return 0;
}

Eure Meinung ist wieder gefragt.
Was mit sehr gefehlt hat, ist eine Funktion oder sowas, mit der ich sehen kann wo sich der Iterator gerade befindet (gibts dass?), kam leider in meinem Buch noch nicht vor.
Was mir auch noch gefehlt hat, wie kann ich einen Iterator mal mehr als ein Element erhöhen/erniedrigen? (den nur mit "++/--" ist dass äußerst aufwendig)
Kam leider auch noch nicht in meinem Buch vor.

MfG
Stromberg

Was mit sehr gefehlt hat, ist eine Funktion oder sowas, mit der ich sehen kann wo sich der Iterator gerade befindet (gibts dass?)

ich weiß nicht, wozu man das brauchen sollte - aber es gibt so etwas:
std::distance (zu finden in <iterator>) - musst nur aufpassen, dass er auch auf den letzten iterator kommt mit dem gegebenen startiterator - sonst siehts bissl schlecht aus ^^

Was mir auch noch gefehlt hat, wie kann ich einen Iterator mal mehr als ein Element erhöhen/erniedrigen?

Mit +=/-= - geht aber imho nur bei random access-containern (std::vector ^^)

for(vector<int>::size_type j = 0; j < elements; ++j) //find es von 0 hübscher ^^
    {
        int temp; //über die initialisierung hier lässt sich sicherlich streiten - ab und an mach ich das zwar auch, aber hier ists denke ziemlich sinnlos ^^
        cin >> temp;
//evtl noch überprüfung auf good, ggf. flags wieder setzen oder direkt mit exceptions arbeiten...
        values.push_back(temp);
    }

so würd ich es jz auf die schnelle machen...

bb

Und end()-1 wäre iter ja eigl. 9. Aber auf 9 kommt man ja nie. Ich bin verwirrt, is glaub schon zu spät für mich, kannst du mir dass bitte nochmal erklären?

MfG
Stromberg

if(iter == last) 
 { 
  cout << "ungerade: " << *iter << endl; 
  break; //hier ^^
 }

also bei 3 Elementen sollte das so in etwa funzen:

1.Element
  iter == last <= false
  -> *iter + *(iter+1) == Summe aus 1+2
-> iter += 2
3.Element
  iter == last <= true
  -> "ungerade: " << *iter
  -> break

das mit dem break lag wohl daran, dass es schon ein wenig später war und so ^^
naja - happy christmas :xmas2:

bb

#include <iterator>

…

std::copy(std::istream_iterator<int>(std::cin), std::istream_iterator<int>(), std::back_inserter(vec));

Einzeiler sind doch toll

Ändern Sie das Programm nun so, dass es zuerst die Summe des ersten und des letzten, dann die Summe des zweiten und des vorletzten Elements ausgibt usw. [bezogen auf 1. Teil]

Hab dass dann so, unter Einbeziehung eurer ganzen Ratschläge, Tipps..., umgesetzt.

#include <iostream>
#include <string>
#include <vector>

using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;

int main()
{
    vector<int>::size_type elements;
    vector<int> values;
    cout << "Wieviele Elemente? ";
    cin >> elements;

    for(vector<int>::size_type i = 0; i<elements; ++i)
    {
        int temp = 0;
        cout << "Wert " << i+1 << ":";
        cin >> temp;
        values.push_back(temp);
    }

    cout << endl;

    for(vector<int>::const_iterator iter_begin = values.begin(), iter_end = values.end()-1;
    iter_begin != iter_end + 1; ++iter_begin, --iter_end)
    {
        if(iter_begin == iter_end)
        {
            cout << "Anzahl der Elemente ist ungerade." << endl;
            cout << "Restwert: " << *iter_begin;
            break;
        }
        cout << *iter_begin + *iter_end << endl;
    }

    return 0;
}

So ists aber doch sehr gut, oder kann man daran noch etwas aussetzen? (Stil / Allg. Verbesserungen?)

MfG
Stromberg

Lesen Sie Text in einen Vektor ein und speichern Sie jedes Wort der Eingabe als Vektorelemenet. Verwandeln Sie die Wörter in Großbuchstaben. Geben Sie die umgewandelten Elemente in Zeilen zu je acht Wörtern aus.

Aber diesmal darf man es nur mit Iteratoren lösen, nicht mit Indizes.

Hier der Code:

#include <iostream>
#include <string>
#include <vector>
#include <cctype>

using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;

int main()
{
    vector<string> words;
    string temp;
    while(getline(cin,temp) and temp != "~")
    {
        words.push_back(temp);
    }

    for(vector<string>::iterator iter = words.begin(); iter != words.end(); ++iter)
    {
        for(string::iterator string_iter = (*iter).begin(); string_iter != (*iter).end(); ++string_iter)
        {
            *string_iter = toupper(*string_iter);
        }

        cout << *iter << " ";
        if((distance(words.begin(),iter) + 1) % 8 == 0) cout << endl; //immer nach 8 Wörtern Zeilenumbruch
    }

    return 0;
}

Eure Meinung? Wie hätte ihr dass gelöst? .....

MfG
Stromberg

for(vector<int>::size_type i = 0; i<elements; ++i)
    {
        int temp = 0;
        cout << "Wert " << i+1 << ":";
        cin >> temp;
        values.push_back(temp);
    }

=>

//cin.exceptions setzen + try/catch drum packen oder fehler-flags nach jeder eingabe prüfen
    for(vector<int>::size_type i = 0; i < elements;)
    {
        cout << "Wert #" << ++i << ":"; //unser i+1
        int temp;
        cin >> temp;
        values.push_back(temp);
    }

for(vector<int>::const_iterator iter_begin = values.begin(), iter_end = values.end()-1; iter_begin != iter_end + 1; ++iter_begin, --iter_end)

1. Wer hat das vorgeschlagen?
2. Was willst du dort machen?

return 0; ist zwar nicht falsch aber warum schreibst du es mit hin?

(*iter).begin()

Wie wärs statt dessen mit iter->begin() - dann sieht man vll auch noch durch?! ^^

for(vector<string>::iterator iter = words.begin(); iter != words.end(); ++iter)

Hier wird jedes mal wieder words.end() aufgerufen... Ist bei Vektor "nur" data+elements - aber trotzdem sinnlos, weil vermeidbar - glaube auch nicht, dass das rausoptimiert wird...

for(vector<string>::iterator iter = words.begin(); iter != words.end(); ++iter)
    {
        for(string::iterator string_iter = (*iter).begin(); string_iter != (*iter).end(); ++string_iter)
        {
            *string_iter = toupper(*string_iter);
        }

        cout << *iter << " ";
        if((distance(words.begin(),iter) + 1) % 8 == 0) cout << endl; //immer nach 8 Wörtern Zeilenumbruch
    }

Ich weiß zwar, dass es so performanter ist, aber ich würde IMMER die eingabe von der verarbeitung und die wiederrum auch von der ausgabe trennen - die geschwindigkeits-einbußen sollten zu vernachlässigen sein, aber man könnte es dann schön in aufgabenbereiche aufsplitten - und es gehört halt einfach nicht zusammen ^^ (ausahmen sind nat., wenn man n elemente addieren soll diese aber danach nicht mehr braucht - aber ich finds trotzdem hässlich so was zu mischen ^^)

bb

Ich habe mir dass so gedacht. Die Aufgabenstellugn war hier doch neu, man sollte das erste und dass letzte Feld addieren, das zweite und das vorletzte...u.s.w.
Somit lass ich einen Iterator von vorne (iter_begin) und einen von hinten (iter_end) ablaufen, und addiere die beiden.

Wie soll ich dass dann verbessern?

for(vector<string>::iterator iter = words.begin(); iter != words.end(); ++iter)

so

const vector<string>::const_iterator end = words.end()
for(.....; iter != end;.......)

??? Oder wie meinst du dass?
Ich kann mir aber nicht vorstellen, dass jedesmal words.end() neu aufgerufen wird, ich glaub schon dass der Compiler des wegoptimiert.

MfG
Stromberg

PS: Danke für deine Hilfe.

Gruß
Don06