Я согласен с ответом @Josh, однако, если по какой-либо причине вы вынуждены следить за состоянием базы данных MySQL, лучше всего выполнить любую серверную часть опроса, чтобы значительно снизить нагрузку на сервер. Одним из таких методов, который я использовал, является создание хранимой процедуры, которая контролирует некоторый результат запроса N раз со сном.
DELIMITER //
CREATE PROCEDURE waitForResults(OUT c INT)
BEGIN
DECLARE n INT DEFAULT 20;
DECLARE x INT;
WHILE n > 0 DO
SELECT SLEEP(0.5) INTO x;
SELECT COUNT(*) FROM `jobs` INTO c;
IF (c > 0) THEN SET n = 0;
ELSE SET n = n - 1;
END IF;
END WHILE;
END //
DELIMITER ;
Затем вы можете запросить базу данных, когда эта хранимая процедура вернется. Знание чего-то изменилось, а затем снова вызвало процедуру, чтобы ждать результатов.
Это хранится как 8-байтовое поле , допускающее диапазон от 1753-01-01 до 9999-12-31, с точностью до 0,00333 секунды.
детали предположительно непрозрачны, но большинство ресурсов (1) , (2) , которые я нашел в Интернете, содержат следующее:
Первые 4 байта хранят количество дней с эпохи SQL Server (1 января 1900 г.) и что вторые 4 байта хранят количество тактов после полуночи, где «такт» составляет 3,3 миллисекунды.
Первые четыре байта подписаны (могут быть положительными или отрицательными), что объясняет, почему могут быть представлены даты, предшествующие эпохе.
int **
- указатель на указатель на int int ** const
- константный указатель на указатель на int int * const *
- указатель на const указатель на int int const **
- указатель на указатель на const int int * const * const
- константный указатель на константный указатель на int И чтобы убедиться, что мы понимаем значение const
const int* foo;
int *const bar; //note, you actually need to set the pointer
//here because you can't change it later ;)
foo
- это указатель переменной на постоянное целое число. Это позволяет вам изменить то, на что вы указываете, но не значение, на которое вы указываете. Чаще всего это наблюдается со строками в стиле C, где есть указатель на const char
. Вы можете изменить строку, на которую указываете, но не можете изменить содержимое этих строк. Это важно, когда сама строка находится в сегменте данных программы и не должна изменяться.
Полоса
- это постоянный или фиксированный указатель на значение, которое можно изменить. Это похоже на ссылку без лишнего синтаксического сахара. Из-за этого обычно используется ссылка, в которой используется указатель T * const
, если только вам не нужно разрешить указатели NULL
.
const
левым из *
, это относится к значению (не имеет значения, является ли это const int
или int const
) const
к праву из *
, это относится к самому указателю важный момент: const int *p
не означает значение, к которому Вы обращаетесь, является постоянным!! . Это означает, что Вы не можете изменить его через тот указатель (значение, Вы не можете присвоить $ *p =... '). Само значение может быть изменено другими способами. Например,
int x = 5;
const int *p = &x;
x = 6; //legal
printf("%d", *p) // prints 6
*p = 7; //error
Это предназначено, чтобы использоваться главным образом в функциональных подписях, гарантировать, что функция не может случайно измениться, аргументы передали.
Общее правило состоит в том, что ключевое слово const
применяется к тому, что ему непосредственно предшествует. Исключение, начальная const
применяется к следующему.
const int *
совпадает с int const *
и означает «указатель на константу int» . const int * const
совпадает с int const * const
и означает «постоянный указатель на константу int» . Изменить: Что касается правил, которые можно и нельзя делать, если этого ответа недостаточно, не могли бы вы уточнить, чего хотите?
Этот вопрос показывает именно , почему мне нравится делать вещи так, как я упомянул в моем вопросе Допускается ли константа после идентификатора типа?
Короче говоря, я нахожу самый простой способ запомнить Правило состоит в том, что "const" идет после объекта, к которому оно применяется. Итак, в вашем вопросе «int const *» означает, что int является постоянным, а «int * const» будет означать, что указатель постоянный.
Если кто-то решит поместить его в самом начале (например: «const int * "), в качестве особого исключения в этом случае оно применяется к вещи после него.
Многие люди любят использовать это специальное исключение, потому что они думают, что оно выглядит лучше. Мне это не нравится, потому что это исключение, и поэтому все запутывается.
Как почти все отметили:
В чем разница между const X * p
, X * const p
и const X * const p
?
Вы должны прочитать объявления указателя справа налево.
const X * p
означает «p указывает на X, который является const»: объект X не может быть изменен с помощью p.
X * const p
означает «p - константный указатель на X, который не является константой»: вы не можете изменить сам указатель p, но вы можете изменить объект X через p.
const X * const p
означает «p является константным указателем на X, который является const ": вы не можете изменить ни сам указатель p, ни объект X с помощью p.
Думаю, здесь уже есть ответы на все вопросы, но я просто хочу добавить, что вам следует остерегаться typedef
s! Это НЕ просто замена текста.
Например:
typedef char *ASTRING;
const ASTRING astring;
Тип astring
- char * const
, а не const char *
. Это одна из причин, по которой я всегда помещаю const
справа от типа, а не в начале.
Простое использование const
.
Самое простое использование - объявить именованную константу. Для этого объявляется константа, как если бы она была переменной, но добавляла перед ней const
. Его нужно сразу инициализировать в конструкторе, потому что, конечно, нельзя установить значение позже, так как это изменит его. Например:
const int Constant1=96;
создаст целочисленную константу, которая невообразимо называется Constant1
, со значением 96.
Такие константы полезны для параметров, которые используются в программе, но их не нужно изменять после компиляции программы. Он имеет преимущество для программистов перед командой препроцессора C #define
в том, что он понимается и используется самим компилятором, а не просто подставляется препроцессором в текст программы до достижения основного компилятора, поэтому сообщения об ошибках намного более полезны.
Он также работает с указателями, но нужно быть осторожным, где const
, чтобы определить, является ли указатель или то, на что он указывает, постоянным или и тем, и другим. Например:
const int * Constant2
объявляет, что Constant2
является указателем переменной на постоянное целое число и:
int const * Constant2
является альтернативным синтаксисом, который делает то же самое, тогда как
int * const Constant3
объявляет, что Constant3
является постоянным указателем на переменное целое число, а
int const * const Constant4
заявляет, что Constant4
является постоянным указателем на постоянное целое число. В основном «const» применяется ко всему, что находится непосредственно слева от него (кроме случаев, когда там ничего нет, и в этом случае он применяется к тому, что находится непосредственно справа от него).
ref: http://duramecho.com/ComputerInformation /WhyHowCppConst.html