Funktion um Kleinbuchstaben in Strings in Großbuchstaben umzuwandeln

Stromberg

So ich habs jetzt so ungefähr geblickt hier ist nochmal eine schöne Version mit der for-Schleife, wie es Konrad Rudolph vorhin mal angesprochen hat. Die is find ich die beste.

#include <iostream>
#include <string>
#include <cctype>
using namespace std;

string upperString(string &s);

int main()
{
    string a="Hans Werner Olm";
    cout << upperString(a) << endl;
    return 0;
}
string upperString(string &s)
{
    string::iterator iter;
    for (iter=s.begin();iter!=s.end();iter++)
    {
        *iter=toupper(*iter);
    }
    return s;
}

Artchi

Ja, es mag sein das du das noch nie gehört hast. Und auf 32bit-CPUs ist es auch eher unwahrscheinlich. Aber nicht auszuschliessen und auf 16 bit oder 8 bit Systemen sogar mehr als wahrscheinlich.

Schau mal das hier (die mir jetzt einfallen):

MSVC Typen unter 32bit-Windows:
int = 32 bit
long = 32 bit
wchar_t = 16 bit

MSVC Typen unter 64bit-Windows:
int = 32 bit
long = 32 bit (hätte man eigentlich 64 bit vermuten können?)
wchar_t = 16 bit

GCC bzw. MinGW unter 32bit-Windows:
wchar_t = 32 bit

Mit den Größen der GCC-Datentypen kenne ich mich sonst weiter nicht aus. Vielleicht weiß jemand, wo man eine Tabelle dazu im Web findet?

Aber man sieht, es ist nichts garantiert, selbst auf ein und dem selben System. Schon ein anderer Compiler kann Unterschiede machen.

ten

Artchi schrieb:

MSVC Typen unter 64bit-Windows:
int = 32 bit
long = 32 bit (hätte man eigentlich 64 bit vermuten können?)

stimmt das?
ich hätte ja schon bei 'int' 64 bits vermutet.
long natürlich auch.

Artchi

Schau einfach in die MSDN, da gibts ne Auflistung aller Typen, die MSVC kennt. Für 64 Bit wurde dagegen __int64 eingeführt. Es gibt noch long long, ich schätze mal, es ist ein typedef auf __int64 (kann ich aber aus der MSDN nicht herauslesen).

http://msdn2.microsoft.com/en-us/library/cc953fe1.aspx

Unter einem 64 Bit GCC kann natürlich int schon 64 Bit sein. Weiß ich aber nicht.

daHa

Artchi schrieb:

Unter einem 64 Bit GCC kann natürlich int schon 64 Bit sein. Weiß ich aber nicht.

auf der kiste da ist sizeof(int) 4 und sizeof(long) 8
(gcc 4.1.2)

Konrad Rudolph

ten schrieb:

Artchi schrieb:

MSVC Typen unter 64bit-Windows:
int = 32 bit
long = 32 bit (hätte man eigentlich 64 bit vermuten können?)

stimmt das?
ich hätte ja schon bei 'int' 64 bits vermutet.
long natürlich auch.

Nene ... allerdings sollte ptrdiff_t 64 Bit haben.

ten

Konrad Rudolph schrieb:

ten schrieb:

Artchi schrieb:

MSVC Typen unter 64bit-Windows:
int = 32 bit
long = 32 bit (hätte man eigentlich 64 bit vermuten können?)

stimmt das?
ich hätte ja schon bei 'int' 64 bits vermutet.
long natürlich auch.

Nene ... allerdings sollte ptrdiff_t 64 Bit haben.

wie? nö, die 64 bits eines '64 bitters' beziehen sich ja auf die anzahl der datenleitungen, registerbreite etc, nicht wie breit der adressbus ist...

Artchi

Hähä, ja, die 64 bit können sich auf alles unterschiedliche beziehen. Bei x86-CPUs auf die Adressraum-Größe: halt 64bit Adressen. Damit kann z.B. ein Athlon64 endlich mehr als 4 GB RAM ansprechen (machen aber die ganzen Mainstream-Mainboards nicht).

Andere 64 Bit CPUs werden wohl nur 32 Bit Adressräume haben. Die damaligen ARM-Prozessoren (ARM 2 und ARM 3) waren echte 32 Bit CPUs, aber der Adressraum war nur 26 Bit groß (das eine 32 Bit Register für den Programmcounter mußte sich ein paar Bits für andere Flags teilen).

Stromberg

Ah ja wenn ich das jetzt alles nochmal zusammenfass hab ich das so verstanden das es verschiedene Compiler gibt und es somit auch mal sein kann das auf einem int ein byte groß ist, obwohl das system z.B. ein 64-bit system ist. Ah ja okay, darum gibts size_t das is n Typ der immer der größtmöglichen vorzeichenlose Ganzzahlentyp auf dem jeweiligen system und jeweiligen compiler ist.
Hm dann stellt sich mir Frage 1: Wieviele Compiler gibt es eigentlich????
Und dann stellt sich mir noch 2: Ich hab schon öfters was von einer ISO\ANSI Norm der Compiler gehört. Aber das kann doch dann bitte nichts mehr mit einer Norm zu tun haben wenn ein int auf einem 32bit system ein byte groß ist. Oder??? Okay ich würde es verstehen wenn auf einem ganz alten Pc der Compiler die Typen einfach automatisch anpasst und somit alle ein Byte z.B. haben.....!
Kann mr jemand dir Fragen beantworten???
Dankeschön schon mal im Voraus.

camper

Konrad Rudolph schrieb:

[std::size_t ist ein vorzeichenloser Ganzzahltyp, der für Größen- und Positions- (Index-) angaben in Containern gedacht ist.

Nein. Dafür ist <container_typ>::size_type bzw difference_type zuständig. Allerdings gibt es eine natürliche Beziehung zwischen beiden Typen (auf Systemen mit flachen Adressräumen).

Artchi schrieb:

2. size_t ist ein Typ, richtig. Es ist der größt mögliche Typ.

Nein.

Artchi schrieb:

int ist bei dir zufällig 32 bit groß. Und was hab ich gesagt? Es muß nicht so sein! int kann auch so groß sein wie ein char!!!!!!!!!!!!! Und willst du dann in einem String höchstens 255 Zeichen speichern können?

Abschnitt 5.2.4.2.1 von C90 enthält Grenzwerte für die Makros in <limits.h>, diese sind damit auch für C++ (vermittelt durch C2/4 in C++98 bzw C++03) gültig. Damit ergeben sich folgende Mindestgrößen in bit:
char: 8
short: 16
int: 16
long: 32

Natürlich kann z.B. sizeof(long)==1 zutreffen, dann hat aber das char auf diesem System wenigstens 32bit.

size_t ist ein vorzeichenloser integraler Typ, dessen Größe durch die Implementation vorgegeben ist (6.3.3.4 in C90 bzw. 6.5.3.4/4 in C99). Es ist also nicht notwendig der größte existierende Typ auf dieser Platform, möglicherweise muss er nicht einmal mit einem der 4 obigen Grundtypen übereinstimmen. Die Bedeutung dieses Typs entsteht dadurch, dass size_t der Ergebnistyp des sizeof Operators ist. ptrdiff_t ist übrigens das vorzeichenbehaftete Equivalent zu size_t (also gleiche Größe). Damit ist auch leicht ein klassisches Beispiel für kleine size_t gegeben:
Auf einem 16bit DOS System sind Segmente (=sequences of contiguous bytes im Sinne von 1.7/1) maximal 64K groß. Folglich muss size_t hier nicht größer als 16bit sein, ein long dagegen immer noch wenigstens 32bit.

Die Größe von wchar_t und bool ist nicht vorgegeben. Allerdings muss wchar_t mit einem der (standardisierten) integeralen Typen hinsichtlich Größe und Repräsentation übereinstimmen.

Um es deutlich zu sagen: es gibt keinen portablen integralen Typ, der auf allen Systemen garantiert der Größte ist.

lolz

Einen String von Klein- in Großbuchstaben umzuwandeln ist ein Einzeiler:

string str = "haLLo WeLt";

transform( str.begin(), str.end(), str.begin(), toupper );

Artchi

Stromberg schrieb:

Hm dann stellt sich mir Frage 1: Wieviele Compiler gibt es eigentlich????

Viele? Alleine für Windows gibts: ICC, MSVC, GCC/MinGW, TurboC++, Portland Group Tools und OpenWatcom. Für andere Systeme, z.B. Großrechner usw. gibts entsprechend auch welche. Z.B. hat IBM seinen XL C/C++. Sun hat seine Sun Studio für Solaris...

Stromberg schrieb:

Und dann stellt sich mir noch 2: Ich hab schon öfters was von einer ISO\ANSI Norm der Compiler gehört. Aber das kann doch dann bitte nichts mehr mit einer Norm zu tun haben wenn ein int auf einem 32bit system ein byte groß ist. Oder??? Okay ich würde es verstehen wenn auf einem ganz alten Pc der Compiler die Typen einfach automatisch anpasst und somit alle ein Byte z.B. haben.....!

Also der Standard (ISO) beschreibt nur die Sprache und die Bibliothek. Teilweise findet man im Standard solche Sachen wie "Das Verhalten von diesem C++ Merkmal ist undefiniert." So in etwa. D.h. dem Compiler- und Library-Hersteller ist es freigestellt, was daraus wird. Dann gibts wieder Sachen, die genaues Verhalten vorschreiben. Z.B. wie eine for-Schleife zu funktionieren hat. Das ist die ISO-C++ Norm. Es ist nur ein Dokument. Und jeder der einen C++ Compiler oder C++ Standard-Library entwickeln will, kann sich danach richten. (muß nicht) Die meisten bekannten Compiler halten sich mittlerweile zu (ich schätze mal) 99% an den C++ Standard. Andere halten sich sehr schlecht dran, wie z.B. der DMC oder OpenWatcom. Und wenn im C++ Standard nicht drin steht, das int 32 Bit sein muß, ist es letztendlich nicht garantiert.

Ansonst kann ich dir diesen Artikel empfehlen:
http://www.c-plusplus.net/forum/viewtopic-var-t-is-159236.html

ten

camper schrieb:

...

camper, du bist in diesem board definitiv 'the king of c++'
:xmas2:

CStoll

Um mal wieder auf den Ursprung zurückzukommen:

Stromberg schrieb:

1. Warum ist der Parameter eine konstante Referenz? Das würde doch auch mit einer nich konstanten gehen, sodass man einfach gleich alles mit der Referenz macht und man müsste somit doch auch keine Hilfsvariable "string s" einführen und bräuchte auch kein return mehr???

An eine const-Referenz kann man auch String-Literale oder (echt) konstante Strings übergeben, an eine normale Referenz nur bestehende String-Variablen - von daher finde ich diese Variante besser (allerdings ist es imho ein Fehler, daß die Funktion anschließend den konstanten String ändern will).

2. Was ist size_t?? Es schaut so aus als wäre das ein Datentyp? Aber was es genau ist weiß ich nicht, kann mir das jemand erklären?

size_t ist groß genug, um alle theoretisch möglichen Typ-Größen entgegenzunehmen - und ist im C Standard definiert (size() liefert eigentlich einen std::string::size_type - aber das ist typischerweise ein typedef für size_t).

4. Was soll genau das string::iterator??? Das blick ich ja mal gar nicht. Ist das auch ein Typ?? schaut so aus aber so genau weiß ich das nicht. Dass bitte auch unbedingt erklären, und dann noch was die Funktion begin() genau bewirkt.

Ein Iterator ist eine Art Smart-Pointer, der die Struktur des unterliegenden Containers besser kennt und sich ansonsten wie ein normaler Zeiger verhält (du kannst ihn inkrementieren, dereferenzieren etc - und string::iterator ist häufig sogar ein normaler Zeiger ;))