Modifica uscita C++ senza cambiare la questione della funzione main()

Question

#include<iostream.h> 
void main() 
{ 
    cout<<"Love"; 
} 

è come possiamo cambiare l'output di questo programma nella "Ti amo" senza fare alcun cambiamento nella main().

Answer 1

È necessario modificare il principale, chiamando un'altra funzione o modificando il testo. Dal main() è l'uscita principale del tuo programma

Answer 2

Puoi essere un po 'più preciso?

Vuoi che l'output di quel pezzo di codice sia "Ti amo" anziché "Amore"?

Modifica: Non penso che non sia possibile senza modificare almeno una riga di codice in main(). È possibile modificare da cout < < "Love" a cout < < "I love you" o semplicemente aggiungere una funzione che emette quella riga specifica.

Answer 3

Non dovrebbe la funzione principale restituire un int? Avrete bisogno di cambiare il metodo, o scrivere un altro programma in cui questo si inserisce, ma questo è il modo più rotondo per cambiare una semplice stringa ...

Answer 4

Quel codice non ha utilizzato std ma in ogni caso richiederebbe di scrivere il proprio wrapper attorno a cout e rimuovere l'utilizzo di std se c'era e sostituire con mystd dove è definito il wrapper.

Answer 5

Immagino che potresti scrivere un operatore < < che ha aggiunto "I" prima e "Tu" dopo l'output corrente.

Answer 6

Ok, fissando la funzione principale e iostream.h ... Questo è il modo

#include <iostream> 

// to make sure std::cout is constructed when we use it 
// before main was called - thxx to @chappar 
std::ios_base::Init stream_initializer; 

struct caller { 
    caller() { std::cout << "I "; } 
    ~caller() { std::cout << " You"; } 
} c; 

// ohh well, for the br0ken main function 
using std::cout; 

int main() 
{ 
    cout<<"Love"; 
} 

ho pensato che avrei dovuto spiegare perché che funziona. Il codice definisce una struttura che ha un costruttore e un distruttore. Il costruttore viene eseguito quando si crea un oggetto della struct e il distruttore viene eseguito quando quell'oggetto viene distrutto. Ora, alla fine di una definizione di struct, puoi mettere i dichiaratori che avranno il tipo caller.

Quindi, quello che abbiamo fatto sopra è la creazione di un oggetto chiamato c che viene costruito (e chiamato il costruttore) all'avvio del programma - anche prima che venga eseguito main. E quando il programma termina, l'oggetto viene distrutto e viene eseguito il distruttore. Nel mezzo, main stampato "Amore".

Questo modello è in realtà molto noto con il termine RAII che di solito rivendica alcune risorse nel costruttore e lo rilascia nuovamente nella chiamata del distruttore.

Answer 7

Ti piace questa:

#include <iostream> 
int main() { 
    std::cout << "I Love You" << std::endl; 
    return 0; 
} 

/* 
#include<iostream.h> 
void main() 
{ 
    cout<<"Love"; 
} 
*/ 

questo modo, non hanno cambiato nulla nel ilmain. :-p

Answer 8

Sembra che tu stia dicendo che non vuoi cambiare il codice, ma vuoi un comportamento diverso. Dal momento che il comportamento desiderato non può essere raggiunto con la magia si hanno due soluzioni reali:

1. O abusare del pre-processore/compilatore, oppure il codice come visto sopra nella soluzione creativa litb.
2. Compilare il codice così com'è per stampare "Amore", ma modificare il file binario generato.

Me? Ero abituato a rompere la protezione contro la copia così mi piacerebbe percorrere la seconda strada. Costruisci il programma dalla sorgente che hai ma poi modifica il file binario in modo che si comporti come preferisci.

Data la natura rotondeggiante di questa soluzione, tuttavia, mi chiedo fortemente delle vostre motivazioni. Sembra una domanda così inutile chiedere a meno che non si capisce compilatori, o hanno la motivazione di sinistro ...

Answer 9

#include <iostream> 
class tclass 
{ 
    public: 
    void operator <<(char *s) 
    { 
      std::cout<<"I"<<s<<"You"<<std::endl; 
    } 
}; 

tclass cout; 

int main() 
{ 
    cout<<"love"; 
} 

Answer 10

Non elegante come litb di, ma un'alternativa:

#include <iostream> 
using namespace std; 

int foo() 
{ 
    cout << "I Love You" << endl; 
    return cout.rdbuf(0); 
} 
int i = foo(); 

int main() 
{ 
    cout << "Love" << endl; 
} 

Answer 11

La lezione è che C++ può eseguire il codice prima e dopo main() tramite costruttori/distruttori statici, ad es. il codice pubblicato da litb.

Answer 12

Non

elegante come litb di, ma funziona

#include <iostream> 
#include <cstdio> 
#include <sstream> 

#define cout  printf("I love you\n"); std::ostringstream os; os 

int main() 
{ 
    cout << "love"; 
} 

Naturalmente, non è necessario utilizzare un stringstream, è possibile utilizzare qualsiasi classe con operator<<.

Answer 13

Supponendo che questo fosse un compito di classe, scommetto che l'idea era di poter riscrivere iostream.h, poiché il C++ non lo tratta come speciale (per alcune definizioni di "speciale").

Answer 14

possiamo farlo in questo modo troppo:

#include <iostream> 
#include <cstdlib> 
using namespace std; 

int fnfoo(int inum){ 
    cout << "I Love You" << endl; 
    return (exit(0),inum); 
} 

int dummy = fnfoo(5); 

int main() 
{ 
    cout << "Love" << endl; 
} 

semplice e funziona perfettamente;)

Answer 15

Sono davvero sorpreso che nessuno ha suggerito #define "Love" "Ti amo" ... :)