domanda per gli esperti di #define

 

Ciao a tutti!

C'è un modo per ottenere una parentesi di chiusura da #define?

#define  LPE );
#define  LP Print( LPE
void OnStart()
  {
   LP "myMessage"
  }
 
Qual è il punto? Per evitare di scrivere le parentesi? È un grosso problema?
 
Dmitry Fedoseev:
Qual è il punto? Quindi non c'è bisogno di scrivere le parentesi? È un grosso problema?


#define  LPRINT_END , __FUNCSIG__);
#define  LPRINT gFactory.getCLogManager().doPrint (

e nel mezzo c'è un messaggio di log

LPRINT "abnormal situation, couldn't select position", ENUM_LOG_LEAD_DEBUG

senza la chiusura.

LPRINT (FUNCSIG, "abnormal situation, couldn't select position", ENUM_LOG_LEAD_DEBUG);

o all'inizio (FUNCSIG a #define e poi una parentesi alla fine

 
Qual è il punto? Quindi non è necessario scrivere le parentesi quando si chiama una macro?
 
Dmitry Fedoseev:
Qual è il punto? Quindi non è necessario scrivere le parentesi quando si chiama la macro?

diciamo che vogliamo aggiungere __FUNCSIG__ e ErrorLast a una macro. Quando la macro viene chiamata, ci sarà una parentesi di chiusura sulla linea con il suo codice. Quindi, sì, un pensiero è balenato intorno, c'è un modo per migliorare questo

 
Nikolai Karetnikov:

diciamo che vogliamo aggiungere __FUNCSIG__ e ErrorLast a una macro. Quando la macro viene chiamata, ci sarà una parentesi di chiusura sulla linea con il suo codice. Quindi, sì, un pensiero è balenato intorno, c'è un modo per migliorare questo

Non c'è modo di rispondere alla mia domanda?

Forse basta usare le macro normalmente? A meno che, ovviamente, non vi cadano le mani da due parentesi.

#define  LP(X) Print(X)
void OnStart()
  {
   LP("myMessage");
  }
 
Dmitry Fedoseev:

Non c'è modo di rispondere alla mia domanda?

Non puoi semplicemente usare le macro in modo corretto? A meno che, ovviamente, non vi cadano le mani da due parentesi.

Avrei dovuto leggere dei parametri, sì )

Grazie!

 

In generale, è così che si risolve:

#define  LOG_S(dText) (SLog(__FUNCSIG__,__FILE__,__LINE__,dText)).Log()
#define  LOG_C(dText) CLog::Get().Log(__FUNCSIG__,__FILE__,__LINE__,dText)
#define  LOG_F(dText) Log(__FUNCSIG__,__FILE__,__LINE__,dText)

struct SLog{
   string cText;
   SLog(string mFunc,string mFile,int mLine,string mText):
      cText(StringFormat("%s, %s, line %i, %s",mFunc,mFile,mLine,mText)){}
   void Log() {Print(cText);}
};

class CLog{
   CLog(){}
public:
   static CLog* Get(){
      static CLog instance;
      return &instance;}
   void Log(string mFunc,string mFile,int mLine,string mText) {PrintFormat("%s, %s, line %i, %s",mFunc,mFile,mLine,mText);}
};

void Log(string mFunc,string mFile,int mLine,string mText) {PrintFormat("%s, %s, line %i, %s",mFunc,mFile,mLine,mText);}


void OnStart(void)
  {
  LOG_S("struct");
  LOG_C("class");
  LOG_F("func");
  }

Tre opzioni: oggetto temporaneo, singoletto, funzione - quello che è più religioso). In termini di velocità, sono praticamente indistinguibili.

 
#define  LOG(dText) printf("%s, %s, line %i, %s",__FUNCSIG__,__FILE__,__LINE__,dText);

void OnStart(void){
  LOG("bezgovna");
}
Ma sfortunatamente non farete colpo sui babbei.
 
Dmitry Fedoseev:
Ma, sfortunatamente, non si fa colpo sui babbei.

Perché non ha mostrato subito questa soluzione all'uomo?)

UPD: bezgovna - scritto senza sh..t ))))
 
Vladimir Simakov:

Perché non ha mostrato subito questa soluzione all'uomo?)

UPD: bezgovna - scritto senza sh..t )))

Grazie! )

Essenzialmente.

Mi sono fermato alla variante con la classe. Anche cose elementari come la parametrizzazione #define si dimenticano rapidamente senza l'uso quotidiano.

Sui nervi.

Dio, come sono sensibili tutti qui; si può fare una domanda senza un'implicazione, senza l'intenzione di offendere o insultare, ma no, da qualche parte nell'anima di un genio non riconosciuto si sente un assillo e un desiderio di affermarsi a spese di un altro dilettante. Non lo incontro sul forum inglese, anche se ci scrivo regolarmente. Rendendomi conto di questo, di solito cerco di non reagire a tali osservazioni, ma se Dmitry, vuoi divertirti in una battaglia verbale, ti darò piacere precipitandoti a capofitto nelle tue stesse emanazioni.

Motivazione: