Различие между объявлениями константы в C++
Закрытие петли & amp; отвечая на мой собственный вопрос.
Во-первых - Действительно, повторные попытки не учитываются для выполненных сообщений.
Как отметил Клаус Ибсен, предпочтительным (самым коротким?) Решением является проверка того, что макет получает ожидаемое количество сообщений. Это будет max_retries + 1 (4 в моем случае). Таким образом, рабочий код выглядит как
@Test
public void simulateError() throws Exception {
/*
* Verify the error handling logic by checking the number of messages that are delivered.
* It must be 1 + number of retries.
*/
mock.expectedMessageCount(maxRetries + 1);
mock.setAssertPeriod(6000); // Necessary to ensure the message count is treated as an exact number.
mock.whenAnyExchangeReceived(new Processor() {
@Override
public void process(Exchange exchange) throws Exception {
System.out.println("Intercepted to-endpoint");
ProcessingFailedException e = new FooException("Error during processing");
exchange.setException(e);
throw e;
}
});
producerTemplate.sendBody(umbFrom, "Hello world");
mock.assertIsSatisfied();
}
6 ответов
Различие - это для
void func(const Class *myClass)
Вы указываете на класс, что не можете измениться, потому что это - константа. Но можно изменить myClass указатель (позвольте ему указать на другой класс; это не имеет никаких побочных эффектов вызывающей стороне, потому что это - указатель, копируется, это только изменяет Ваше локальное копия указателя), По контрасту
void func(Class *const myClass)
Теперь myClass указывает на класс, который может быть изменен, в то время как Вы не можете изменить параметр.
В первом Вы объявляете функцию, которая принимает указатель на постоянный Объект класса. Вы не можете изменить объект в функции. Во втором Вы объявляете функцию, которая принимает постоянный указатель на не постоянный Объект класса. Вы можете изменить объект через указатель, но не можете изменить указатель, ценят себя.
Я всегда имею в виду это легкое правило: const всегда применяется на вещь в непосредственном, оставленном его, если эта вещь не делает существует, это относится к вещи на непосредственном праве.
Также смотрите к этому вопросу, который я задал неделю назад, он указывает на некоторые очень полезные ссылки для понимания правильности константы.
Эмпирическое правило состоит в том, чтобы считать объявления справа налево:
void func(const Class *myClass) указатель на Класс константы (или строго говоря "указатель на Класс, который является константой"),
void func(Class *const myClass) указатель константы на Класс
Прием должен считать эти вещи назад:
void func(const Class *myClass)
Чтения "myClass являются указателем на Класс, который является константой", что означает, что я не могу внести изменения в Классе
void func(Class *const myClass)
Чтения "myClass являются указателем константы на Класс", что означает, что я не могу изменить указатель.
В C++ это
const MyClass *ptr
и это
MyClass const *ptr
оба имеют в виду это ptr переменный указатель, который указывает на постоянный объект типа MyClass. Таким образом, Вы не можете изменить упомянутый объект через ptr. Однако можно сделать ptr самостоятельно укажите на некоторый другой объект MyClass.
Напротив, это
MyClass *const ptr
подразумевает ptr постоянный указатель, указывающий на переменную MyClass объект. Здесь можно действительно изменить объект, на который указывает ptr, но Вы не можете сделать ptr указать на некоторый другой объект.
Обратите внимание, что среди вышеупомянутых трех видов синтаксиса, второй немного нечетен, но это - допустимый синтаксис. Это не следует за левыми к правильному правилу чтения, что другие люди здесь имеют, предлагают. Но затем, это - жизнь в C++ для Вас.
void func(const Class *myClass) { //...
Как упомянуто в других ответах, это определение означает что параметр myClass точки к экземпляру Class это не может быть изменено (mutable и const_cast исключенный) функцией. Однако myClass переменная в теле функции могла быть изменением для указания на другой экземпляр Class. Это - деталь реализации функции.
void func(Class *const myClass) { // ...
С другой стороны, это определение означает что myClass параметр является указателем на a Class экземпляр, который не является константой и следовательно может использоваться функцией, чтобы полностью управлять экземпляром класса, но что myClass сама переменная указателя не может быть изменена для указания на что-либо еще в теле функции.
Один важный вопрос, который не был поднят другими ответами, - то, что для функциональных подписей, любой высокоуровневой константы или энергозависимой квалификации игнорируется при рассмотрении типа функции. Это вызвано тем, что параметры всегда передаются значением, поэтому являются ли они константой, или не только влияет, может ли сам параметр быть изменен в теле функции и не может влиять на вызывающую сторону.
Таким образом эти два объявления функции эквивалентны.
void func(Class *const myClass);
void func(Class *myClass);