Действительно ли #pragma - как только сейф включает защиту?
//Model Class should be like this
struct JsonResposne : Codable {
let categories : [String]?
enum CodingKeys: String, CodingKey {
case categories = "Categories"
}
init(from decoder: Decoder) throws {
let values = try decoder.container(keyedBy: CodingKeys.self)
categories = try values.decodeIfPresent([String].self, forKey: .categories)
}
}
func getCategoriesResponse() {
Alamofire.request(requestUrl, method: .post, parameters: params, encoding: URLEncoding.default).responseJSON { (response) in
switch response.result {
case .success:
if response.data != nil {
do {
let decoder = JSONDecoder()
let apiResponse:JsonResponse = try decoder.decode(JsonResponse.self, from: responseData)
print(apiResponse.categories.count)
}catch {
print(error.localizedDescription)
}
}
}
break
case .failure:
print("There was something with your call")
break
}
}
}
9 ответов
Использование #pragma Once должно работать на любом современном компиляторе, но я не вижу никаких причин не использовать стандартный #ifndef include guard , Работает просто отлично. Единственное предостережение в том, что GCC не поддерживал #pragma один раз до версии 3.4 .
Я также обнаружил, что, по крайней мере в GCC, он распознает стандарт #ifndef включает в себя guard и оптимизирует его , поэтому он не должен быть намного медленнее, чем #pragma один раз .
Я бы хотел Однажды #pragma (или что-то подобное) было в стандарте. Включить охранников
Я не знаю никаких преимуществ в производительности, но это, безусловно, работает. Я использую его во всех своих проектах C ++ (если я использую компилятор MS). Я считаю, что это более эффективно, чем использование
#ifndef HEADERNAME_H
#define HEADERNAME_H
...
#endif
. Он выполняет ту же работу и не заполняет препроцессор дополнительными макросами.
GCC официально поддерживает #pragma начиная с версии 3.4 .
Я использую его, и я доволен им, поскольку мне приходится печатать намного меньше, чтобы создать новый заголовок. У меня это работало нормально на трех платформах: Windows, Mac и Linux.
У меня нет никакой информации о производительности, но я считаю, что разница между #pragma и защитой включения не будет ничем по сравнению с медлительностью синтаксического анализа грамматики C ++. Это настоящая проблема. Попробуйте скомпилировать такое же количество файлов и строк с помощью компилятора C #, например, чтобы увидеть разницу.
В конце концов, использование guard или pragma не будет иметь никакого значения.
Использование ' #pragma Once ' может не иметь никакого эффекта (оно не поддерживается везде - хотя и все чаще поддерживается), поэтому вам нужно использовать условную компиляцию Код в любом случае, и в таком случае зачем использовать ' #pragma Once '? Компилятор, вероятно, все равно его оптимизирует. Это зависит от вашей целевой платформы, хотя. Если все ваши цели поддерживают это, тогда продолжайте и используйте это - но это должно быть сознательное решение, потому что весь ад развалится, если вы только используете прагму, а затем портируете на компилятор, который не поддерживает его.
Преимущество в производительности заключается в том, что не нужно повторно открывать файл после того, как # однажды прагма была прочитана. С защитой компилятор должен открыть файл (который может быть дорогостоящим по времени), чтобы получить информацию, что он не должен снова включать его содержимое.
Это теория только потому, что некоторые компиляторы автоматически не открывают файлы, которые не ' В каждом модуле компиляции не должно быть никакого кода чтения.
В любом случае, это относится не ко всем компиляторам, поэтому в идеале нужно избегать использования #pragma, поскольку кросс-платформенный код вообще не является стандартным / не имеет стандартизированного определения. и эффект. Тем не мение, практически, это действительно лучше, чем охранники.
В конце, лучшее предложение, вы можете получить , чтобы быть уверенным, что ваша компилятор будет иметь лучшую скорость без необходимости проверять поведение каждого компилятора в этом случае. , означает использовать как прагму один раз, так и охрану.
#ifndef NR_TEST_H
#define NR_TEST_H
#pragma once
#include "Thing.h"
namespace MyApp
{
// ...
}
#endif
Таким образом, вы получаете лучшее из обоих (кроссплатформенная и справочная скорость компиляции).
Поскольку печатать дольше, я лично использую инструмент, который помогает генерировать все это очень хитрым способом (Visual Assist X).
Using gcc 3.4 and 4.1 on very large trees (sometimes making use of distcc), I have yet to see any speed up when using #pragma once in lieu of, or in combination with standard include guards.
I really don't see how its worth potentially confusing older versions of gcc, or even other compilers since there's no real savings. I have not tried all of the various de-linters, but I'm willing to bet it will confuse many of them.
I too wish it had been adopted early on, but I can see the argument "Why do we need that when ifndef works perfectly fine?". Given C's many dark corners and complexities, include guards are one of the easiest, self explaining things. If you have even a small knowledge of how the preprocessor works, they should be self explanatory.
If you do observe a significant speed up, however, please update your question.
#pragma once имеет один недостаток (кроме нестандартности), а именно, если у вас есть один и тот же файл в разных местах (у нас это есть потому, что наша система сборки копирует файлы вокруг), то компилятор будет думать, что это разные файлы.
Сегодня охранники старой школы работают так же быстро, как #pragma once. Даже если компилятор не обрабатывает их специально, он все равно остановится, когда увидит, что #ifndef WHATEVER и WHATEVER определены. Открытие файла сегодня обходится очень дешево. Даже если бы и было улучшение, оно было бы в миллисекундах.
Я просто не использую #pragma один раз, потому что это бесполезно. Чтобы избежать конфликтов с другими средствами защиты включения, я использую что-то вроде: CI_APP_MODULE_FILE_H -> CI = Company Initials; APP = Название приложения; остальное говорит само за себя.