Physical Boost.Units Deficytowane przez użytkownika literały

Question

Teraz, gdy wkrótce mamy zdefiniowane przez użytkownika literały (UDL), na przykład w GCC 4.7, z niecierpliwością czekam na (fizyczne) biblioteki jednostek (takie jak Boost.Units) używając ich w celu ułatwienia ekspresji literałów, takich jak 1+3i, 3m,lub , lub . Czy ktoś napisał rozszerzenie do Boost.Units przy użyciu UDL obsługujących to zachowanie?

Answer 1

Nikt nie wyszedł z takim rozszerzeniem. Tylko GCC (i prawdopodobnie IBM?) Ma UDL, więc może trochę potrwać. Mam nadzieję, że jakieś jednostki zmienią się w tr2, które zaczynają się teraz. Jeśli tak się stanie, na pewno pojawią się UDL dla jednostek.

to działa:

// ./bin/bin/g++ -std=c++0x -o units4 units4.cpp 

#include <boost/units/unit.hpp> 
#include <boost/units/quantity.hpp> 
#include <boost/units/systems/si.hpp> 

using namespace boost::units; 
using namespace boost::units::si; 

quantity<length, long double> 
operator"" _m(long double x) 
{ return x * meters; } 

quantity<si::time, long double> 
operator"" _s(long double x) 
{ return x * seconds; } 

int 
main() 
{ 
    auto l = 66.6_m; 
    auto v = 2.5_m/6.6_s; 
    std::cout << "l = " << l << std::endl; 
    std::cout << "v = " << v << std::endl; 
} 

myślę, że nie byłoby zbyt trudne, aby przejść przez ciebie ulubionych zespołów i to zrobić.

Dotyczy umieszczenia ich w bibliotece: Operatory literałów są funkcjami przestrzeni nazw. Konkurs na sufiksy stanie się brzydki. I (gdybym Boost) musiałby

namespace literals 
{ 
... 
} 

Następnie zwiększyć użytkownicy mogą robić

using boost::units::literals; 

wraz ze wszystkimi innymi z wykorzystaniem decls zazwyczaj używają. Wtedy na przykład nie zostaniesz zbezczeszczony przez std::tr2::units. Podobnie, jeśli rzucisz własną.

Answer 2

Moim zdaniem nie ma zbyt wiele korzyści z używania literałów dla Boost.Units, ponieważ można jeszcze bardziej wydajną składnię z istniejącymi możliwościami.

W prostych przypadkach wygląda na to, że literały są drogą, ale wkrótce okazuje się, że nie jest zbyt potężna. Na przykład nadal musisz zdefiniować literały dla jednostek połączonych, na przykład, jak wyrażasz 1 m/s (jeden metr na sekundę)?

Aktualnie

auto v = 1*si::meter/si::second; // yes, it is long 

ale z literałów?

// fake code 
using namespace boost::units::literals; 
auto v = 1._m_over_s; // or 1._m/si::second; or 1._m/1_s // even worst 

Lepsze rozwiązanie można osiągnąć dzięki istniejącym funkcjom. I to jest to, co robię:

namespace boost{namespace units{namespace si{ //excuse me! 
namespace abbreviations{ 
    static const length    m = si::meter; 
    static const time    s = si::second; 

    // ... 
} 
}}} // thank you! 

using namespace si::abbreviations; 
auto v = 1.*m/s; 

W ten sam sposób można zrobić: auto a = 1.*m/pow<2>(s); lub rozszerzyć skróty więcej, jeśli chcesz (np static const area m2 = pow<2>(si::meter);)

Co jeszcze poza tym chcesz?

Może łączny rozwiązaniem mogłoby być sposobem

auto v = 1._m/s; // _m is literal, /s is from si::abbreviation combined with operator/ 

ale nie będzie tak dużo zbędny kod, a zysk jest minimalny (zastąpić * przez _ po numerze.)

Jedna wada mojego rozwiązania jest to, że polutes przestrzeń nazw z nazw pospolitych jedna litera. Ale nie widzę sposobu, z wyjątkiem dodania podkreślenia (na początku lub na końcu skrótu), tak jak w 1.*m_/s_, ale przynajmniej mogę zbudować wyrażenia prawdziwych jednostek.