Codifica in C++

[angelaporfidia]

Salveee
spero mi aiuterete a risolvere questo problemino di informatica:
devo fare una codifica in cui devo utilizzare prima una funzione--> string upcase (string s), e qui upcase sarebbe il nome mentre il parametro è una stringa che ho chiamato s; poi devo utilizzare la funzione main, in cui vado a richiamare la funzione upcase. Nella funzione upcase devo convertire tutti i caratteri di s in maiuscolo, e poi stampare s facendo return s. Nella funzione main, invece, devo fare cout<<''inserisci un nome''; cin>>nome; poi nome=upcase(nome); ed infine cout<
ho fatto tutto, ma il programma non va..ora metto sotto la codifica che ho fatto io:

#include
using namespace std;
string upcase (string s) {
int nome,i;
for (i=0; i if (nome >='a' && nome <='z') {
nome = nome -32;
}
}
return s;
}
int main () {
int nome;
cout<<"inserisci un nome";
cin>>nome;
nome= upcase (nome);
cout< system ("pause");
}

l'errore che mi da (e molto probabilmente ce ne saranno anche altri) è il for.
Mi date una manoo??

[claudio862]

Il messaggio di errore dovrebbe darti un indizio di quale sia il problema:

# Compilando con Clang
a.cpp:5:18: error: member reference base type 'int' is not a structure or union
 for (i=0; i<nome.length(); i++) {
             ~~~~^~~~~~~

# Compilando con GCC
a.cpp: In function 'std::string upcase(std::string)':
a.cpp:5:19: error: request for member 'length' in 'nome', which is of non-class type 'int'

# Compilando con Visual Studio
a.cpp(5) : error C2228: left of '.length' must have class/struct/union
        type is 'int'

Cerchi di chiamare la funzione membro "length" della variabile "nome", che però è di tipo "int".

In entrambe le funzioni, hai dichiarato "nome" come int, invece che come string.

[vict85]

Per prima cosa immagino tu stia seguendo lo stesso corso di tony.95. Infatti stiamo parlando del tuo problema qui. La prossima volta guarda e metti il tuo messaggio all'interno della stessa discussione per non dover ripetere le cose 10 volte.

L'errore è comunque quello che ti ha fatto notare Claudio. Detto questo sarebbe più "professionale" se upcase usasse un reference invece di usare il costruttore di copia.

Usa il tag code

[code]

[/code]


Comunque hai fatto altri tre errori:
[list=1][*:lna90rqi]hai dimenticato

#include <string>

[/*:m:lna90rqi][*:lna90rqi]devi scrivere

return nome;

e non

return s;

[/*:m:lna90rqi][*:lna90rqi]nome non è inizializzato[/*:m:lna90rqi][/list:o:lna90rqi]

[angelaporfidia]

Ciao claudio86
verissimo, ho dichiarato nome con int anziché string...ho aggiustato, ma è sorto un altro problema: il programma ora va, ma non mi converte il nome in maiuscolo! :S

[vict85]

Vedi le correzioni sopra. A me ora funziona.

[angelaporfidia]

#include
#include
using namespace std;
string upcase (string s) {
string nome;
int i;
for (i=0; i if (nome >='a' && nome <='z') {
nome = nome -32;
}
}
return nome;
}

int main () {
string nome;
cout<<"inserisci un nome";
cin>>nome;
nome= upcase (nome);
cout< system ("pause");
}

dovrebbe essere così?

[vict85]

Usa il tag code! Usarlo in questa sezione non è un optional. Facilita la lettura e ti permette di copiare tutti il codice velocemente.

Comunque hai dimenticato l'inizializzazione di nome. D'altra parte nome, come variabile in upcase, è inutile.

Questa è la versione corretta:

string upcase (string s) {
	for (size_t i=0; i < s.length(); i++) {
		if (s[i]>='a' && s[i] <='z') {
			s[i] -= 32;
		}
	}
	return s;
}

Anche se è meglio così:

void upcase (string &s) {
	for (size_t i=0; i < s.length(); i++) {
		if (s[i]>='a' && s[i] <='z') {
			s[i] -= 32;
		}
	}
}

trasformando il main così:

int main () {
	string nome;
	cout<<"inserisci un nome: ";
	cin>>nome;
	upcase(nome);
	cout<<nome<<endl;
	system ("pause");
}

-----------------------------------------------------------------------
P.S.: X Claudio: anche se in C++11 si potrebbe scrivere

così:

void upcase (string &s) {
	for( char &c : s) { c = toupper(c); };
}

[claudio862]

@vict85
Mi piace di più la prima, è più semplice convertire una stringa costante (usando la seconda dovresti prima farne una copia).


Si può anche usare std::transform (in quella pagina c'è proprio quest'esempio).

std::string upcase (std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), static_cast<int (*)(int)>(std::toupper));
    return s;
}

(il cast serve per disambiguare da un'altra funzione std::toupper definita nell'header )

[vict85]

Ma la funzione

string f(string);

non ti evita certo le copie.

[claudio862]

"vict85":Ma la funzione

string f(string);

non ti evita certo le copie.

Stai violando le regole dell'ottimizzazione!
- Don’t do it.
- (For experts only!): Don’t do it yet.
- Profile first.

Comunque in questo caso potrebbe essere meglio passare per valore.

Morale (per engy): mai preoccuparsi troppo dell'efficienza. Una volta scritto il codice, se è troppo lento, si vede dove migliorare, e lì si migliora.

[apatriarca]

Se proprio si vogliono evitare copie.. si può evitare di usare stringhe. Funziona perché l'input da console viene scritto in un buffer di dimensione fissa e la lettura non prosegue fino alla pressione del carattere di a capo (scritto in C).

#include <ctype.h>
#include <stdio.h>

int main(void)
{
    int c;

    puts("Inserisci il testo da convertire e poi premi invio.");
    do {
        c = getchar();
        (void)putc(toupper(c), stdout);
    } while (c != '\n');

    return 0;
}

EDIT: Ovviamente non sto dicendo che questo sia il modo giusto di implementare qualcosa del genere. E' una soluzione tutt'altro che prima di problemi, primo fra tutti il fatto che dipende dall'implementazione dell'input da console da parte del sistema operativo. Su Windows (compilando il codice con Pelles C) ad un certo punto diventa impossibile aggiungere ulteriori caratteri perché il buffer è terminato. In altri sistemi operativi il comportamento potrebbe essere anche molto diverso.

E' però ridicolo discutere di performance su un codice del genere governato dai tempi di I/O. Soprattutto se la discussione riguarda una classe di implementazione ignota. Classe che è possibile evitare di usare completamente.