Следующий метод, на этот раз на стороне SQL, должен использовать метод convert в вашем запросе sql:
CONVERT(VARCHAR(11),$user_date,111)
//e.g.
SELECT CONVERT(VARCHAR(11),DATEFIELD,111) AS DATE
//or
SET DATEFIELD = CONVERT(VARCHAR(11),'".$user_date."',111)
См.: http://www.w3schools.com/sql/func_convert. asp - число в конце изменяет тип формата даты, с возвратом 111: 2006/12/30.
Простой пример с использованием std :: sort
struct MyStruct {int key; std :: string stringValue; MyStruct (int k, const std :: string & amp; s): key (k), stringValue (s) {}}; struct less_than_key {inline bool operator () (const MyStruct & amp; struct1, const MyStruct & amp; struct2) {return (struct1.key & lt; struct2.key); }}; std :: vector & lt; MyStruct & gt; VEC; vec.push_back (MyStruct (4, "test")); vec.push_back (MyStruct (3, "a")); vec.push_back (MyStruct (2, "is")); vec.push_back (MyStruct (1, «this»)); std :: sort (vec.begin (), vec.end (), less_than_key ());
Редактировать: Как указал Кирилл В. Лядвинский, вместо предоставления предиката сортировки вы можете реализовать оператор & lt;
для MyStruct [ ! d3]:
struct MyStruct {int key; std :: string stringValue; MyStruct (int k, const std :: string & amp; s): key (k), stringValue (s) {} Оператор bool & lt; (const MyStruct & amp; str) const {return (key & lt; str.key); }};
Используя этот метод, вы можете просто отсортировать вектор следующим образом:
std :: sort (vec.begin (), vec.end () );
Edit2: Как говорит Каппа, вы также можете отсортировать вектор в порядке убывания, перегрузив оператор & gt;
и немного изменив вызов сортировки:
struct MyStruct {int key; std :: string stringValue; MyStruct (int k, const std :: string & amp; s): key (k), stringValue (s) {} bool operator & gt; (const MyStruct & amp; str) const {return (key & gt; str.key); }};
И вы должны вызвать сортировку как:
std :: sort (vec.begin (), vec.end (), больше & lt; MyStruct & gt; ( ));
// пример алгоритма сортировки #include & lt; iostream & gt; // std :: cout #include & lt; algorithm & gt; // std :: sort #include & lt; vector & gt; // std :: vector с использованием пространства имен std; int main () {char myints [] = {'F', 'C', 'E', 'G', 'A', 'H', 'B', 'D'}; вектор & л; символ & GT; myvector (myints, myints + 8); // 32 71 12 45 26 80 53 33 // используя сравнение по умолчанию (operator & lt;): sort (myvector.begin (), myvector.end ()); // (12 32 45 71) 26 80 53 33 // распечатать содержимое: cout & lt; «myvector содержит:»; для (int i = 0; i! = 8; i ++) cout & lt; '' & lt; & lt; myvector [i]; cout & lt; '\n'; Система ( "Пауза"); return 0; }
typedef struct Freqamp {double freq; двойной усилитель; } FREQAMP; bool struct_cmp_by_freq (FREQAMP a, FREQAMP b) {return a.freq & lt; b.freq; } main () {vector & lt; FREQAMP & gt; темп; FREQAMP freqAMP; freqAMP.freq = 330; freqAMP.amp = 117,56; temp.push_back (freqAMP); freqAMP.freq = 450; freqAMP.amp = 99,56; temp.push_back (freqAMP); freqAMP.freq = 110; freqAMP.amp = 106,56; temp.push_back (freqAMP); sort (temp.begin (), temp.end (), struct_cmp_by_freq); }
, если сравнение ложно, оно будет «обмениваться».
Мне было любопытно, есть ли какое-либо измеримое влияние на производительность между различными способами вызова std :: sort, поэтому я создал этот простой тест:
$ cat sort.cpp # включают & л; алгоритм & GT; # Включают & л; iostream & GT; # Включают & Lt; & вектор GT; # Включают & л; хроно & GT; #define COMPILER_BARRIER () asm volatile ("" ::: "memory"); typedef unsigned long int ulint; использование пространства имен std; struct S {int x; int y; }; #define BODY {return s1.x * s2.y & lt; s2.x * s1.y; } bool operator & lt; (const S & amp; s1, const S & amp; s2) BODY bool Sgreater_func (const S & amp; s1, const S & amp; s2) BODY struct Sgreater {bool operator () (const S & amp; s1, const S & amp; s2) const BODY }; void sort_by_operator (vector & lt; s & amp; v) {sort (v.begin (), v.end ()); } void sort_by_lambda (vector & lt; s & amp; v) {sort (v.begin (), v.end (), [] (const S & amp; s1, const S & amp; s2) BODY); } void sort_by_functor (vector & lt; s & amp; v) {sort (v.begin (), v.end (), Sgreater ()); } void sort_by_function (vector & lt; s & amp; v) {sort (v.begin (), v.end (), & amp; Sgreater_func); } const int N = 10000000; вектор & л, S & GT; random_vector; ulint run (void foo (вектор & lt; S & gt; v)) {вектор & lt; S & gt; TMP (random_vector); Foo (TMP); ulint checksum = 0; for (int i = 0; i & lt; tmp.size (); ++ i) {checksum + = i * tmp [i] .x ^ tmp [i] .y; } контрольная сумма возврата; } void measure (void foo (vector & lt; S & gt; & amp; v)) {ulint check_sum = 0; // разминка const int WARMUP_ROUNDS = 3; const int TEST_ROUNDS = 10; for (int t = WARMUP_ROUNDS; t -;) {COMPILER_BARRIER (); check_sum + = run (foo); COMPILER_BARRIER (); } for (int t = TEST_ROUNDS; t -;) {COMPILER_BARRIER (); auto start = std :: chrono :: high_resolution_clock :: now (); COMPILER_BARRIER (); check_sum + = run (foo); COMPILER_BARRIER (); auto end = std :: chrono :: high_resolution_clock :: now (); COMPILER_BARRIER (); auto duration_ns = std :: chrono :: duration_cast & lt; std :: chrono :: duration & lt; double & gt; gt; (end-start) .count (); cout & lt; «Взял» & lt; duration_ns & lt; 's, чтобы закончить круглый & lt; & lt; епсИ; } cout & lt; "Контрольная сумма:" & lt; check_sum & lt; епсИ; } #define M (x) \ cout & lt; «Измерение» #x «on» & lt; N & lt; "items:" & lt; endl; \ measure (x); int main () {random_vector.reserve (N); for (int i = 0; i & lt; N; ++ i) {random_vector.push_back (S {rand (), rand ()}); } M (sort_by_operator); М (sort_by_lambda); М (sort_by_functor); М (sort_by_function); return 0; }
Что он делает, так это создает случайный вектор, а затем измеряет, сколько времени требуется для его копирования и сортировки его копии (и вычислить некоторую контрольную сумму, чтобы избежать слишком сильного мертвого кода исключение).
Я компилировал с g ++ (GCC) 7.2.1 20170829 (Red Hat 7.2.1-1)
$ g ++ -O2 -o сортировка сортировки. cpp & amp; & amp; ./sort
Вот результаты:
Измерение sort_by_operator на 10000000 элементах: Взял 0.994285s, чтобы завершить раунд. Взял 0.990162s, чтобы завершить раунд. Принимал 0.992103s до полный раунд Взял 0.989638s, чтобы завершить раунд Взял 0.98105s, чтобы завершить раунд Взял 0.991913s, чтобы завершить раунд Взял 0.992176s, чтобы завершить раунд Взял 0.981706s, чтобы завершить раунд Взял 0.99021s, чтобы завершить раунд Взял 0.988841s для завершения раунда Контрольная сумма: 18446656212269526361 Мера sort_by_lambda on 10000000 предметов: Взял 0.974274s, чтобы завершить раунд Взял 0.97298s, чтобы завершить раунд Взял 0.964506s, чтобы завершить раунд Взял 0.96899s, чтобы завершить раунд Взял 0.965773s, чтобы завершить раунд Взял 0.96457s, чтобы завершить раунд Взял 0.974286s, чтобы завершить раунд Взял 0.975524s, чтобы закончить раунд раунд Взял 0,966238s для завершения раунда Взял 0,964676s для завершения раунда Контрольная сумма: 18446656212269526361 Мера sort_by_functor на 10000000 предметов: Взял 0.964359s, чтобы завершить раунд Взял 0.979619s, чтобы завершить раунд Взял 0.974027s для завершения раунда Взял 0,964671s, чтобы завершить раунд Взял 0,964764s, чтобы завершить раунд Взял 0,966491s, чтобы завершить раунд Взял 0,964706s, чтобы завершить раунд Взял 0,965115s, чтобы завершить раунд Взял 0,964352s, чтобы завершить раунд Взял 0,968954s для завершения раунда Контрольная сумма: 18446656212269526361 Мера sort_by_function на 10000000 статьях : Взял 1.29942s, чтобы завершить раунд Взял 1.3029s, чтобы закончить раунд Взял 1.29931s, чтобы закончить раунд Взял 1.29946s, чтобы закончить раунд Взял 1.29837s, чтобы закончить раунд Took 1.30132s, чтобы закончить раунд Взял 1.3023s, чтобы закончить раунд Взял 1.30997s, чтобы закончить раунд Took 1.30819s для завершения раунда Took 1.3003s для завершения раунда Контрольная сумма: 18446656212269526361
Похоже, что все параметры, кроме указателя функции, очень похожи, а передача указателя функции вызывает + 30% -ный штраф.
Он также выглядит как оператор & lt; версия на ~ 1% медленнее (я повторил тест несколько раз, и эффект сохраняется), что немного странно, поскольку предполагает, что сгенерированный код отличается (мне не хватает навыков для анализа --save-temps output).
В вашем классе вы можете перегрузить символ "& lt;" оператор
класс MyClass {bool operator & lt; (const MyClass & amp; rhs) {return this- & gt; key & lt; rhs.key; }}
& gt;
вместо & lt;
, чтобы получить убывающий порядок.
– bhaller
27 April 2017 в 04:53
Вы можете использовать функтор в качестве третьего аргумента в std :: sort
, или вы можете определить оператор & lt;
в вашем классе.
struct X {int x; bool operator & lt; (const X & amp; val) const {return x & lt; val.x; }}; struct Xgreater {bool operator () (const X & amp; lx, const X & amp; rx) const {return lx.x & lt; rx.x; }}; int main () {std :: vector & lt; X & gt; my_vec; // используем X :: operator & lt; по умолчанию std :: sort (my_vec.begin (), my_vec.end ()); // используем functor std :: sort (my_vec.begin (), my_vec.end (), Xgreater ()); }
const
в конце подписи указывает, что функция operator ()
не изменяет экземпляр структуры Xgreater
(которая в общем случае могут иметь переменные-члены), тогда как указание const
для входных значений указывает только на то, что эти входные значения неизменяемы.
– schester
28 December 2017 в 20:35
Да, std :: sort ()
с третьим параметром (функцией или объектом) будет проще. Пример: http://www.cplusplus.com/reference/algorithm/sort/
Вы на правильном пути. std :: sort
будет использовать operator & lt;
в качестве функции сравнения по умолчанию. Поэтому для сортировки ваших объектов вам придется либо перегрузить bool operator & lt; (const T & amp ;, const T & amp;)
, либо предоставить функтор, который выполняет сравнение, например:
struct C {int i; static bool before (const C & amp; c1, const C & amp; c2) {return c1.i & lt; c2.i; }}; bool operator & lt; (const C & amp; c1, const C & amp; c2) {return c1.i & gt; c2.i; } std :: vector & lt; C & gt; значения; std :: sort (values.begin (), values.end ()); // использует оператор & lt; std :: sort (values.begin (), values.end (), C :: before);
Преимущество использования функтора заключается в том, что вы можете использовать функцию с доступом к закрытым членам класса.
operator & lt;
членом класса (или структуры), поскольку глобальный может использовать защищенные или частные члены. Или вы должны сделать его другом структуры C.
– Kirill V. Lyadvinsky
4 September 2009 в 18:25
Чтобы отсортировать вектор, вы можете использовать алгоритм sort () в.
sort (vec.begin (), vec.end (), less & lt; int & gt; ());
Третий используемый параметр может быть больше или меньше, а также использовать любую функцию или объект. Однако оператор по умолчанию равен & lt; если вы оставите третий параметр пустым.
// используя функцию as comp std :: sort (myvector.begin () + 4, myvector.end (), myfunction); bool myfunction (int i, int j) {return (i & lt; j); } // использование объекта as comp std :: sort (myvector.begin (), myvector.end (), myobject);
Ниже приведен код с использованием lambdas
#include "stdafx.h" #include & lt; vector & gt; #include & lt; algorithm & gt; использование пространства имен std; struct MyStruct {int key; std :: string stringValue; MyStruct (int k, const std :: string & amp; s): key (k), stringValue (s) {}}; int main () {std :: vector & lt; MyStruct & gt; VEC; vec.push_back (MyStruct (4, "test")); vec.push_back (MyStruct (3, "a")); vec.push_back (MyStruct (2, "is")); vec.push_back (MyStruct (1, «this»)); std :: sort (vec.begin (), vec.end (), [] (const MyStruct & amp; struct1, const MyStruct & amp; struct2) {return (struct1.key & lt; struct2.key);}); return 0; }
std :: sort (vec.begin (), vec.end (), больше & lt; MyStruct & gt; ())
, который является чистым и элегантным. – kappa 31 May 2014 в 00:21#include & lt; functional & gt;
использовать «std :: больше». – Nick Hartung 31 August 2015 в 15:21operator & lt;
и использовать либоstd :: sort (vec.begin (), vec.end ());
илиstd :: sort (vec.rbegin (), vec.rend ());
в зависимости от того, хотите ли вы иметь восходящий или нисходящий порядок. – Pixelchemist 19 May 2016 в 22:24