Aiuto con C++ Opzioni

[infinite_devil]

Ragazzi un aiutino in C++

(si, è una cosa oscenamente stupida, lo so...)

CODICE

#include "stdafx.h"
#include <iostream>
using namespace std;
#include <string>
#define N 5;

int s,tot;

int Somma(int s, int tot);

int Somma(int s, int tot) {
    cout<<"Inserisci: ";
    cin>>s;
    tot=N+s;
    return tot;
}


void main() {

    tot=Somma(s,tot);
    
    cout<<"Totale: "<<tot<<"\n";
    
    system("pause");
}

Perchè qualsiasi cosa io dia in input, mi da fuori 5 ?

Messaggio modificato da infinite_devil il Wednesday 26 September 2012 - 19:17

[.:Niki:.]

N è una costante (#DEFINE N 5;) non può essere modificata.

Puoi risolvere così:

CODICE

#include "stdafx.h"
#include <iostream>
using namespace std;
#include <string>


int s,tot;
const int N=5;

int Somma(int s, int tot);

int Somma(int s, int tot) {
    cout<<"Inserisci: ";
    cin>>s;
    tot=N+s;
    return tot;
}


void main() {

    tot=Somma(s,tot);
    
    cout<<"Totale: "<<tot<<"\n";
    
    system("pause");
}

EDIT: Se ho sbagliato qualcosa è colpa delle 7 ore di scuola in 2 giorni che faccio Java D:
RiEDIT: Ha ragione darean15, mea culpa.

Messaggio modificato da .:Niki:. il Wednesday 26 September 2012 - 19:38

[darean15]

Non ci deve essere il ; dopo il valore della costante

CODE

#include "stdafx.h"
#include <iostream>
using namespace std;
#include <string>
#define N 5

int s,tot;

int Somma(int s, int tot);

int Somma(int s, int tot) {
cout<<"Inserisci: ";
cin>>s;
tot=N+s;
return tot;
}


void main() {

tot=Somma(s,tot);

cout<<"Totale: "<<tot<<"\n";

system("pause");
}

[Trivia]

Permettimi anche di aggiungere che #DEFINE N 5 non è neanche una costante nel senso C++ del termine, ma una direttiva al preprocessore C-style.

Chiaramente #define è usata anche in C++, ma per altri motivi (es. header guards), mentre il modo corretto di dichiarare costanti in C++ è usare la parola chiave const prima di una ordinaria dichiarazione di variabile.
Solo queste sono costanti propriamente dette (per cui c'è cioè allocazione di spazio in memoria) e per cui è esplicitamente specificato un tipo. Ad esempio, puoi avere una costante di tipo size_t quando questo è il tipo più indicato (es. dimensioni di un array), mentre con le costanti C-style avviene una semplice sostituzione del literal.

Il concetto principe è che, a meno che tu non sia a scuola e dunque purtroppo soggetto ai capricci dei prof., è importante dedicare attenzione durante lo studio del C++ alla qualità del proprio materiale e che non sia solo materiale per C adattato.
Al proposito, suggerisco sempre Accelerated C++ oppure Programming: Principles and Practice Using C++ e, per utenti più avanzati C++ Primer (Lippman).

[jocopoco]

Credo che sia didatticamente che teoricamente nel caso specifico usare const invece di define sia un po sbagliato. Le origini del C e di conseguenza del C++ erano di sostituire l'assembler creando un linguaggo piu vicino all'uomo e non di creare un italiano perfetto (per quello ce Leopardi). L'uso di const trova applicazioni in casi piu' complessi.

Messaggio modificato da jocopoco il Wednesday 26 September 2012 - 19:52

[Trivia]

Credo che sia didatticamente che teoricamente nel caso specifico usare const invece di define sia un po sbagliato. Le origini del C e di conseguenza del C++ erano di sostituire l'assembler creando un linguaggo piu vicino all'uomo e non di creare un italiano perfetto.
L'uso di const trova applicazioni in casi piu' complessi.

Quando si parla di questi argomenti dire "un po' sbagliato" senza portare dei controesempi non serve a molto... perché non saprei su che base risponderti. Diciamo che quello che hai detto vale assolutamente e sacrosantamente per il C.
Viceversa, oltre a prog. generica e OO, il C++ ha come punto concettuale importante una maggiore type safeness e avere costanti tipizzate è assolutamente in linea con le specifiche progettuali.

Chiaro che il mio consiglio resta solo un consiglio e ognuno sceglie da se ^ _ ^ ma per me C e C++ sono due linguaggi con importanti differenze progettuali, e queste si riflettono sul modo più corretto di scrivere codice nell'uno piuttosto che nell'altro.

Tra l'altro, usando #define il preprocessore sostituisce N nell'ambito dell'intero file, laddove invece con const si ha un controllo fine sullo scope del nome che si introduce (limitandolo ad es. solo alla funzione in cui è utilizzato).

Come consigli a infinite_devil aggiungerei di utilizzare uno stile di naming coerente.
Ad es. perché main, giustamente, in minuscolo mentre la funzione Somma ha una iniziale maiuscola? Questo stile in C++ è solitamente riservato ai nomi dei tipi (classi, struct...).
Poi mi raccomando di scegliere nomi specifici per le funzioni. Una funzione che si chiama "Somma" non spiega facilmente che sommerà 5... e pensa che nei tuoi programmi più complessi potresti avere un numero enorme di funzioni.
Ad esempio somma_cinque, per quanto orribile, è più indicato in questo caso.
Mi ricollego al discorso sul const per dire che uno dei pregi dell'usare questa sintassi è che puoi dichiarare la costante all'interno della funzione somma, evitando di inquinare il namespace globale. Abituati a lasciare globali meno nomi possibili!

[infinite_devil]

Grazie mille per l'aiuto e per le preziosissime informazioni... @mod: non chiudete il topic perchè prevedo di uppare frequentemente

a meno che tu non sia a scuola e dunque purtroppo soggetto ai capricci dei prof.

@Trivia: quel programma che ho postato era una cazzatina fatta a caso per capire la logica di tutto un altro programma, ecco il perchè della funzione chiamata semplicemente "Somma" e dell'inutilità di sommare una variabile inserita dall'utente ad una costante
Riguardo alla "Somma" maiuscola, ordini del prof: "in C++ scrivete tutto in minuscolo eccetto le cose cose come nomi di variabili o altre cose che comunque inserite voi... eccetto con le funzioni, perchè è una direttiva che vengano scritte con la prima lettera maiuscola"

Messaggio modificato da infinite_devil il Wednesday 26 September 2012 - 20:35

[Trivia]

Riguardo alla "Somma" maiuscola, direttive del prof: "in C scrivete tutto in minuscolo eccetto le cose cose come nomi di variabili o altre cose che comunque inserite voi... eccetto con le funzioni, perchè è una direttiva che vengano scritte con la prima lettera maiuscola"

Anche se io uso uno stile diverso e in effetti non c'è nessuna direttiva del genere, ancor più che maiuscolo o minuscolo è importante che lo stile sia consistente quindi... finché lo rispetti sempre, poco male e il prof. non si arrabbierà ^ _ ^
Se cerchi online troverai l'ebook gratuito Thinking in C++ di Bruce Eckel (forse esiste anche una traduzione italiana) che dedica un capitolo proprio a questo tipo di scelte di stile (oltre a essere un buon libro di per se).

È un buon modo per farsi anche un po' di cultura "clandestina" e chissà che non inizi a sgamare anche qualche errore del prof. =p (io ho fatto il liceo classico e non mi sono mai potuto togliere questo sfizio ).

[jocopoco]

Tengo a precisare un piccola cosa entrando anche nell'OT della discussione e credo che non sia chiaro solo per me che const estende un concetto che la #define fa' ovvero di definire delle variabili che nel programma non ha senso modificare. const estende questo concetto allargandolo (sinteticamente) anche ai parametri ed ai valori restituiti. (mi sto chiedendo cosa sia sbagliato ?)

Messaggio modificato da jocopoco il Thursday 27 September 2012 - 05:11

[Trivia]

Tengo a precisare un piccola cosa entrando anche nell'OT della discussione e credo che non sia chiaro solo per me che const estende un concetto che la #define fa' ovvero di definire delle variabili che nel programma non ha senso modificare. const estende questo concetto allargandolo (sinteticamente) anche ai parametri ed ai valori restituiti. (mi sto chiedendo cosa sia sbagliato ?)

Non è proprio così, o meglio, questo vale per il qualificatore const, ed in questo caso la parola "variabili" ci sta in quanto c'è un'effettiva allocazione di spazio in memoria. Tra l'altro il C++ offre anche l'operatore const_cast per rimuovere la constness ma esclusi casi di incompatibilità di interfaccia (es. usando funzioni di una libreria C) o uso congiunto con il qualificatore volatile non penso ci siano tanti buoni motivi per usarlo

La cosa sbagliata è che la direttiva #define non introduce affatto delle variabili ma istruisce il preprocessore su una sostituzione testuale di un certo simbolo (es. N) con un certo valore (es. 5). N non è una variabile perché non c'è allocazione di memoria, semplicemente il literal 5 viene inserito nel codice ad ogni evenienza di N.
Questo significa tra le altre cose che l'uso dei "magic number" è nascosto a chi legge il codice, ma non al compilatore che processerà l'output del preprocessore e dunque, in caso di errori, non mostrerà mai i simboli del preprocessore bensì i magic number stessi.
Poi chiaramente ci sono i due discorsi di cui ho parlato prima, cioè type safeness e scope della costante, e a questo punto ci metterei anche il principio della minima distanza di una variabile dal punto in cui viene usata.
Con #define il nome è globale e dunque ha unicamente senso posizionare la direttiva vicino alle altre direttive (fanno eccezione in alcuni casi #ifdef o #ifndef, es. per codice di debug, ma è un'altra storia) e questo ci impedisce di averla comodamente alla minima distanza dal suo uso.
Per questo principio, oltre che la gestione dei magic number, un buon riferimento è Code Complete di McConnell, che pur non amando sperticatamente come il 90% dei lettori, mi sembra una buona guida per questioni di "ing. del software di tutti i giorni".

[Prace]

Aggiungo che usare const al posto del #define è anche caldamente consigliato (per gli stessi motivi) da uno dei libri più apprezzati per il C++, Effective C++, ottimo per passare dal livello "principiante" a quello "avanzato". Io ho letto questo libro dopo aver cominciato a programmare in C++ leggendo Accelerated C++, anch'esso ottimo libro per i principianti L'unica pecca è che sono solo in inglese :/

[Gemini]

In questo caso usare const come variabile globale al posto di define non porta alcun vantaggio, anzi. Con const viene specificato al compilatore di inserire il nostro valore costante da qualche parte nel segmento TEXT dell'eseguibile, necessitando in seguito il caricamento dello stesso per essere usato dalle operazioni tra registri (a meno che il compilatore non appiattisca il tutto, ma con GCC questa magagne sono all'ordine del giorno). Con un define la differenza è che non c'è alcuna necessità di caricare dati dalla memoria, avendo già tutto nell'opcode che andrà a eseguire la somma, indipendentemente che il codice sia ottimizzato o meno, e ci si risparmia pure quei 4 byte di int globale in TEXT.

[jocopoco]

Mi pare di aver scritto variabili per usare un liguaggio tecnico e semplice anche con qualche inesatezza. Consiglio anch'io di usare il const solamente dove è necessario per esempio quando la nosta #define viene utilizzata per stringhe. La mia è una precisazione relativa al caso specifico e mi piace sfatare luoghi comuni sbagliati

Messaggio modificato da jocopoco il Thursday 27 September 2012 - 10:55

[Gemini]

Le stringhe sono esattamente l'esempio calzante di perfetto utilizzo di const, soprattutto se gli accessi alla stessa cella sono ripetuti e non si vuole andare a usare una variabile temporanea di supporto. Const è praticamente il pane quotidiano di chi i puntatori li usa come se non ci fosse un domani.

Messaggio modificato da Gemini il Thursday 27 September 2012 - 10:56

[Trivia]

In questo caso usare const come variabile globale al posto di define non porta alcun vantaggio, anzi. Con const viene specificato al compilatore di inserire il nostro valore costante da qualche parte nel segmento TEXT dell'eseguibile, necessitando in seguito il caricamento dello stesso per essere usato dalle operazioni tra registri (a meno che il compilatore non appiattisca il tutto, ma con GCC questa magagne sono all'ordine del giorno). Con un define la differenza è che non c'è alcuna necessità di caricare dati dalla memoria, avendo già tutto nell'opcode che andrà a eseguire la somma, indipendentemente che il codice sia ottimizzato o meno, e ci si risparmia pure quei 4 byte di int globale in TEXT.

Su questo siamo d'accordo, quello che fai è un ottimo discorso di ottimizzazione, anche se questo può essere un problema solo se stiamo lavorando su macchine molto particolari (e qui penso che proprio tu hai solo da insegnare).
Ma quando si lavora su macchine come un pc moderno dove 4 byte non sono un problema né in eseguibile né in memoria, penso vada premiato uno stile di programmazione consistente e quando si lavora in C++ penso che sarai d'accordo che non può essere una direttiva che non ci da alcun controllo sullo scope e sul tipo.

Le linee guida per la programmazione in C++ dicono ad esempio che tutto quello che va confrontato in un ciclo utilizza il tipo size_t, ma con #define si è limitati a inserire nel testo un int literal. E questa mi sembra una situazione in cui anche un principiante si può trovare (es. dimensioni di un array) e tutt'altro che complessa.

Edit: Sono anche abbastanza sicuro, ma non ho fonti in questo momento, che in casi come questo in cui non avvengono casting et similia, il compilatore ottimizza l'uso della costante C++-style con una sostituzione testuale, rendendo praticamente assimilabile l'eseguibile a quello con uso del #define, ma lasciando inalterati tutti i pregi che ho già elencato (scoping, tipizzazione, debugging, controllo sintattico...). Sono dispostissimo a confrontare al volo due listati, anzi, lo farò in mattinata.

[Prace]

Le linee guida per la programmazione in C++ dicono ad esempio che tutto quello che va confrontato in un ciclo utilizza il tipo size_t, ma con #define si è limitati a inserire nel testo un int literal. E questa mi sembra una situazione in cui anche un principiante si può trovare (es. dimensioni di un array) e tutt'altro che complessa.

Salvo poi che il ::size_t non lo usa nessuno (e la cosa mi fa incazzare, perchè oltre ad essere sicuro come tipo è pure più "bello" da leggere), tutti i miei colleghi usano unsigned int probabilmente per retaggio del C ma non mi piace proprio. In linguaggi complessi come il C++ lo stile e la leggibilità sono tutto, imho

[jocopoco]

Il c++ è tanto vecchio che uno nuovo standard è stato rilasciato. Ci sono linguaggi piu evoluti com Java o C# per la programmazione ad oggetti. Finirà come il pascal tanto studiato mai usato

PS:

Sono in convalescenza

Messaggio modificato da jocopoco il Thursday 27 September 2012 - 11:14

[Trivia]

(a meno che il compilatore non appiattisca il tutto, ma con GCC questa magagne sono all'ordine del giorno).

Ti confermo che ho fatto qualche prova e gli eseguibili che ho ottenuto sono perfettamente uguali (gcc 4.2.1).
Chiaramente con const ci possono essere dei margini di "non-appiattimento" per via della possibilità di un const_cast.

Però tengo a sottolineare che nessuna catastrofe di 4 byte persi si è verificata

Il c++ è tanto vecchio che uno nuovo standard è stato rilasciato. Ci sono linguaggi piu evoluti com Java o C# per la programmazione ad oggetti. Finirà come il pascal tanto studiato mai usato

Personalmente ho un grande rispetto per quel pachiderma del C++, ma non lo userei più per la maggior parte dei miei progetti personali, non quando ci sono alternative come appunto C#.
È anche vero che sul C++ c'è tanta letteratura che spinge verso uno stile di programmazione più moderno (STL e relativi algoritmi, eccezioni...) ma ogni persona nella sua personalissima condizione professionale e/o hobbistica deve rendersi conto se questo gli serve o se fa prima a muoversi direttamente su un altro linguaggio; come io faccio non appena ne ho la possibilità
Il caso di infinite_devil poi è diverso, lui deve studiarlo a scuola e quindi amen

[Gemini]

Però tengo a sottolineare che nessuna catastrofe di 4 byte persi si è verificata

Con tutta probabilità perché l'operazione è assimilabile a un semplice opcode, ma con casi più ricorrenti (soprattutto con cast di vario genere o accessi con puntatori e riferimenti) la variabile finisce su TEXT e con lei molti dei riferimenti. Ora immagine se ne hai parecchie altre così, ci fai uno sfacelo. Finché si tratta di variabili semplici una bella macro o un'enumerazione sono la cosa migliore da usare, anche perché di buona norma sono più digeribili al compilatore e tendono a creare meno spazzatura di ottimizzazione.

Personalmente ho un grande rispetto per quel pachiderma del C++, ma non lo userei più per la maggior parte dei miei progetti personali, non quando ci sono alternative come appunto C#.

Io invece lo uso veramente per tutto quello che programmo, nonostante abbia provato ogni possibile alternativa (C# escluso, mi è sempre mancato l'interesse di andarlo a guardare). Avendo il mio bel framework per lavorare con stringhe, immagini, suoni e quant'altro con il minimo dello sforzo non sento neppure la necessità di usare qualcosa di "più semplice" (e che al solito ti costa qualcosa in termini di prestazioni). Ultimamente mi sono fatto anche un set di classi per gestire le WinAPI incapsulate in maniera umana, abbandonando il criptico MFC e passando a librerie 100% fatte in casa (e che so perfettamente come manipolare per sfruttarle al massimo).

[Trivia]

Con tutta probabilità perché l'operazione è assimilabile a un semplice opcode, ma con casi più ricorrenti (soprattutto con cast di vario genere o accessi con puntatori e riferimenti) la variabile finisce su TEXT e con lei molti dei riferimenti. Ora immagine se ne hai parecchie altre così, ci fai uno sfacelo. Finché si tratta di variabili semplici una bella macro o un'enumerazione sono la cosa migliore da usare, anche perché di buona norma sono più digeribili al compilatore e tendono a creare meno spazzatura di ottimizzazione.

Ma alcune di queste operazioni non sono possibili a priori usando #define (es., non puoi avere un puntatore che punti a una #define). Tu mi dirai giustamente che non è questo il caso e io ti rispondo giustamente che infatti in questo caso gcc produce lo stesso identico eseguibile.
Se stessimo programmando per DS sarei più facilmente d'accordo col tuo argomento, che comunque è di per se corretto, anche se poi al momento della valutazione personale dei pro e dei contro per me prevarrebbero quelli che ho elencato negli altri post (senza considerare che parliamo da vari post di 4 byte quando avendo il controllo sul tipo della costante molto spesso si userebbero degli short).
Inoltre con const posso avere delle costanti il cui nome è valido all'interno di un particolare namespace, altra comodità di cui approfitto spesso e che con #define è inapplicabile.

Io invece lo uso veramente per tutto quello che programmo, nonostante abbia provato ogni possibile alternativa (C# escluso, mi è sempre mancato l'interesse di andarlo a guardare). Avendo il mio bel framework per lavorare con stringhe, immagini, suoni e quant'altro con il minimo dello sforzo non sento neppure la necessità di usare qualcosa di "più semplice" (e che al solito ti costa qualcosa in termini di prestazioni). Ultimamente mi sono fatto anche un set di classi per gestire le WinAPI incapsulate in maniera umana, abbandonando il criptico MFC e passando a librerie 100% fatte in casa (e che so perfettamente come manipolare per sfruttarle al massimo).

Ovviamente esistono mille ottimi motivi per usare C++, soprattutto se ormai lo conosci come le tue tasche e hai le tue classi che ti danno garanzie di solidità. Non mi permetterei mai di mettere bocca, sono valutazioni personali al 100%.
Ad esempio qualche mese fa avevo bisogno di un software che analizzasse dei tag che usavo nei commenti di un progetto molto vasto, e che usavo per segnalarmi alcune cose a distanza di giorni. Il progetto era in C++ ma questo programma l'ho scritto in Ruby, e penso di aver risparmiato bel tempo ma magari tu l'avresti fatto in 2 minuti anche in C++, quindi ritorniamo a quanto queste considerazioni sui linguaggi siano personalissime.