Linq
1.0.0
LINQ para la comprensión de la lista en C ++, proporciona una implementación de LINQ para C ++. Actualmente solo admite rangos de C ++, pero sí admite los métodos de extensión y consulta para LINQ. Aquí hay un ejemplo:
struct student_t
{
std :: string last_name ;
std :: vector < int > scores ;
} ;
std :: vector < student_t > students =
{
{ "Omelchenko" , { 97 , 72 , 81 , 60 } } ,
{ "O'Donnell" , { 75 , 84 , 91 , 39 } } ,
{ "Mortensen" , { 88 , 94 , 65 , 85 } } ,
{ "Garcia" , { 97 , 89 , 85 , 82 } } ,
{ "Beebe" , { 35 , 72 , 91 , 70 } }
} ;
auto scores = LINQ ( from ( student , students )
from ( score , student . scores )
where ( score > 90 )
select ( std :: make_pair ( student . last_name , score ) ) ) ;
for ( auto x : scores )
{
printf ( "%s score: %i n " , x . first . c_str ( ) , x . second ) ;
}El código C ++ anterior emitirá esto (sí, ese es el código C ++ arriba):
Omelchenko score: 97
O'Donnell score: 91
Mortensen score: 94
Garcia score: 97
Beebe score: 91
Las extensiones se implementan utilizando el | Operador de tubería. Esto les permite aplicar a cualquier rango, sin requerir inhear de alguna clase de base especial. Entonces las extensiones pueden funcionar así:
vector< int > numbers = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 };
auto r = numbers
| linq::where([]( int x) { return x > 2 ; })
| linq::select([]( int x) { return x * x; });Los métodos de extensión admitidos son:
La biblioteca también proporciona una clase range_extension , que también se puede usar para escribir sus propias extensiones. Primero, simplemente defina la clase de función de función, como esta:
struct contains_t
{
template < class Range , class T >
bool operator ()(Range && r, T && x) const
{ return (r | linq::find (x)) != boost::end (r); };
};Luego inicialice la extensión utilizando la inicialización estática:
range_extension< contains_t > contains = {};Entonces la extensión se puede usar así:
if (numbers | contains( 5 )) printf( " We have a 5 " ); Todas las consultas de Linq deben comenzar con una declaración from . Esto especifica el nombre de la variable que se utilizará para los lambdas y el contenedor al que se aplicarán las consultas. Además, se pueden usar múltiples from .
struct student
{
std :: string name ;
std :: vector < int > grades ;
student ( ) { }
template < class Range >
student ( std :: string name , Range && r )
: name ( name ) , grades ( boost :: begin ( r ) , boost :: end ( r ) )
{ }
} ;
std :: vector < student > students =
{
student ( "Bob" , { 90 , 100 , 75 } )
student ( "Tom" , { 92 , 81 , 70 } )
student ( "Terry" , { 105 , 98 , 94 } )
} ;
// { 90, 100, 75, 92, 81, 70, 105, 98, 94 }
auto q = LINQ ( from ( s , students ) from ( g , s . grades ) select ( g ) ) ; La cláusula Where devuelve el elemento que coincide con el predicado. Es opcional, pero debe venir después de una cláusula from y debe ser antes de una cláusula select si hay una.
vector < int > v = { 1 , 3 , 4 , 5 } ;
// { 1, 3, 5 }
auto q = LINQ ( from ( i , v ) where ( i % 2 ) ) ;La cláusula SELECT aplica una transformación a los elementos. También es opcional, pero debería ser la última cláusula.
std :: vector < int > v = { 1 , 2 , 4 } ;
// { 3, 6, 24 }
auto q = LINQ ( from ( x , v ) select ( x * 3 ) ) ; La cláusula orderby le permite especificar elementos para ordenar el rango por. El selector también puede precedir ascending o descending para especificar la dirección del orden. El valor predeterminado es ascender.
struct person
{
std :: string name ;
int age ;
person ( ) { }
person ( std :: string name , int age )
: name ( name ) , age ( age )
{ }
} ;
std :: vector < person > people =
{
person ( "Tom" , 25 ) ,
person ( "Bob" , 22 ) ,
person ( "Terry" , 37 ) ,
person ( "Jerry" , 22 )
}
// { "Jerry", "Bob", "Tom", "Terry" }
auto q = LINQ ( from ( p , people ) orderby ( p . age , descending p . name ) select ( p . name ) ) ; La cláusula group agrupa los elementos de una secuencia. El primer parámetro es el selector de clave, y el segundo es el selector de valor.
struct person
{
std :: string name ;
int age ;
person ( ) { }
person ( std :: string name , int age )
: name ( name ) , age ( age )
{ }
} ;
std :: vector < person > people =
{
person ( "Tom" , 25 ) ,
person ( "Bob" , 22 ) ,
person ( "Terry" , 37 ) ,
person ( "Jerry" , 22 )
}
auto q = LINQ ( from ( p , people ) group ( p . age , p . name ) ) ; Linq se puede instalar fácilmente con CGG:
cget install pfultz2/Linq
Esto instalará la dependencia de Boost automáticamente. La biblioteca también se puede instalar manualmente con Cmake.
find_package(Linq) también está disponible para consumir Linq de CMake:
find_package(Linq)
target_linkq_libraries(yourLib linq::linq)
Para el soporte completo, requiere Clang o GCC, y Boost. Hay apoyo parcial para Visual Studio. Visual Studio no es compatible con las extensiones default_if_empty , group_by , group_join , join , order_by , select_many y then_by , y no admite orderby , group y anidadas de las cláusulas. Quizás algunos asistentes de Visual Studio podrían ayudar a encontrar soluciones para los errores MSVC.
Múltiples from declaraciones se implementan utilizando lambdas anidadas. Sin embargo, debido a un error en MSVC 2010, los lambas anidados no funcionan (esto debería solucionarse en MSVC 2012, pero no lo he probado). Si hay una manera de implementar identificadores transparentes en C ++, se podrían evitar los lambdas anidados.
Además, las cláusulas let y join aún no son compatibles. La cláusula into no puede ser compatible sin la ayuda de lambdas polímorhpic.
BSL-1.0
