C++: nascondendo alcune funzioni

Question

Ho ridefinito alcune funzioni matematiche (in modo che siano più veloci, meno precisi o utilizzare i modelli). Metto queste funzioni in un namespace e funzionano bene.

Capita spesso, però, che mi dimentico di chiamare funzioni dal mio spazio dei nomi (ad esempio: ho dimenticato di scrivere mymath::cos o using mymath::cos; quando voglio chiamare cos), ed è abbastanza difficile per scoprire dove ho dimenticato (fino ora l'ho scoperto solo con il profiling).

Dato che

• ho solo includono standard di math.h o cmath intestazioni all'interno della mia intestazione di matematica, e che
• ho bisogno di includere le intestazioni matematiche standard (perché alcune delle mie funzioni sono solo wrapper per lo standard uno, e voglio loro di essere in linea o che stanno su modelli),

c'è un modo portatile per nascondere funzione matematica standard in modo che venga segnalato un errore di compilazione, se vengono utilizzate funzioni matematiche globali (ovvero: senza uno spazio dei nomi)?

Una soluzione potrebbe essere mettere un using namespace mymath; nella parte inferiore del mio file di intestazione matematica, ma questa soluzione non sembra così grande: rompe l'intero scopo dei namespace; Preferirei dover dire esplicitamente se usare una funzione da mymath o da std in modo che io sia costretto a scegliere tra un fester o una funzione più accurata senza il rischio di dimenticarlo.

---

EDIT:

Molte risposte dire che se uso cos dal namespace globale (senza utilizzare né stdmymath), e comprendono cmath (e non math.h), la compilazione dovrebbe fallire.

non so cosa dice la norma su di esso, ma:

#include <cmath> 
int main() { 
    cos(M_PI); 
    return 0; 
} 

compila bene con GNU GCC (g++) 4.5.1 (e versioni precedenti).

Answer 1

mettere questo in un file di intestazione, e #include ovunque:

namespace DontUseMe { 
double cos (double) ; 
// ...etc. 
} 
using namespace DontUseMe ; 

Answer 2

Se si include solo cmath e non math.h, tutte le funzioni da tale intestazione devono trovarsi nello spazio nomi :: std ::. Non usare mai using namespace std; e starai bene. (cmath è solo math.h con tutte le cose in uno spazio dei nomi)

Answer 3

Che ne dite di questa idea: dopo compreso < math.h>, utilizzare definire come segue:

#define sin blahblahblah (just to generate an error) 
#define cos blahblahblah (just to generate an error) 

Quello che succede è che ogni peccato sarà sostituito da blahblahblah, che causerà un errore. Ma ciò che accadrà è che mymath :: sin sarà sostituito da mymath :: blahblahblah (perché #define funziona letteralmente), quindi genererà anche un errore. In questo caso, se vuoi semplificare il compito per te, definisci temporaneamente la funzione blahblahblah in mymath per evitare di mostrare l'errore per mymath :: sin, quindi compila e correggi tutti quegli errori.

Tuttavia, consiglierei di creare "Trova nei file" e di esaminare tutte le funzioni, e sono sicuro che non parlerà più di un'ora per un progetto su larga scala.

Spero che questo aiuti.

saluti,
RAFID

Answer 4

Avete bisogno di includere le intestazioni math.h e CMATH direttamente nel file di intestazione? Se avete bisogno di, provare tra cui l'intestazione come questo:

namespace arbitrary_name 
{ 
    #include <math.h> 
} 

Questo conterrà tutte le definizioni math.h all'interno di un nuovo spazio dei nomi, in modo da non li userete accidentalmente altrove.

Questa non è la soluzione ideale. Forse c'è un modo migliore per farlo usando spazi dei nomi anonimi, ma la soluzione non mi è chiara.

Answer 5

Sfortunatamente la soluzione più affidabile sarà quella di non utilizzare gli stessi nomi di funzioni della libreria standard. Fortunatamente i nomi delle funzioni standard sono concisi e fortemente abbreviati, quindi nomi come cosine(), sine(), exponent(), arctan() sarebbero unici (e probabilmente migliori) senza dover adornare il nome con prefissi maldestri.

In alternativa si potrebbe mantenere gli stessi nomi, ma li capitalizzare: Sin(), Cos(), Exp() ecc

Answer 6

Scrivi alcune funzioni wrapper in un file separato.

#include <math.h> 

namespace my_wrapper 
{ 

float sin(float n) 
{ 
    return std::sin(float n); 
} 

}; 

O qualcosa del genere. E quindi utilizzare solo quelli negli altri file e non includere nemmeno o negli altri file soure. Sì, è un piccolo problema scrivere le funzioni di inoltro per tutti, ma è solo un lavoro e non ce ne sono molti ...

Con un moderno compilatore che collega la generazione del codice temporale e può essere in linea tra i file oggetto questo non dovrebbero essere inefficiente ...

Answer 7

mia risposta preferita di Clifford finora, ma c'è un'altra alternativa si potrebbe prevedere: modificare la intestazioni standard per questo progetto (solo).

Dovrebbe essere presente un'opzione con il compilatore di scelta per indicare dove si trova la libreria standard, pertanto è possibile duplicare l'STL nel progetto e modificare i file in modo che i nomi non validi non vengano più iniettati nello spazio dei nomi globale.

Si tratta di hacker, ma questo è l'unico modo che posso pensare, a corto di controllare il codice con uno script per qualsiasi occorrenza di cos/sin che non è qualificato (cioè immediatamente preceduto da ::).