Макрос __FILE__ показывает полный путь

Стандартный предопределенный макрос __ FILE__ , доступный в C, показывает полный путь к файлу. Есть ли способ сократить путь? Я имею в виду вместо

 /full/path/to/file.c  

вижу

  в/file.c  

или

  file.c  

Попробуйте

  #include  #define __FILENAME__ (strrchr (__ FILE__, '/')? strrchr (__ FILE__,  '/') + 1: __FILE__)  

Для Windows используйте ‘\’ вместо ‘/’.


Вот совет, если вы используете cmake. От: http://public.kitware.com/pipermail/cmake/2013-January/053117.html

Я копирую совет, поэтому все на этой странице:

  set (CMAKE_CXX_FLAGS "$ {CMAKE_CXX_FLAGS} -D__FILENAME __ = '" $ (subst $ {CMAKE_SOURCE_DIR}/,, $ (abspath $  

Если вы используете GNU make, я не вижу причин, по которым вы не могли бы распространить это на свои собственные make-файлы. Например, у вас может быть такая строка:

  CXX_FLAGS + = - D__FILENAME __ = ' "$ (subst $ (SOURCE_PREFIX)/,, $ (abspath $  

где $ (SOURCE_PREFIX) — префикс, который вы хотите удалить.

Затем используйте __ FILENAME__ вместо __ FILE__ .

14


Я только что подумал об отличном решении для этого, которое работает как с исходными файлами, так и с заголовочными файлами, очень эффективно и работает во время компиляции на всех платформах без расширений, специфичных для компилятора. Это решение также сохраняет относительную структуру каталогов вашего проекта, поэтому вы знаете, в какой папке находится файл, и только относительно корня вашего проекта.

Идея состоит в том, чтобы получить размер файла исходный каталог с помощью инструмента сборки и просто добавьте его в макрос __ FILE__ , полностью удалив каталог и показывая только имя файла начинается с исходного каталога.

Следующий пример реализован с использованием CMake, но нет никаких причин, по которым он не будет работать с другими инструментами сборки, потому что это очень простой трюк.

В файле CMakeLists.txt определите макрос, который имеет длину пути к вашему проекту в CMake:

  # Дополнительный/важен  чтобы удалить последний символ из пути. # Обратите внимание, что не имеет значения, использует ли ОС/или , потому что мы только # сохраняем размер пути. строка (LENGTH "$ {CMAKE_SOURCE_DIR}/" SOURCE_PATH_SIZE) add_definitions ("- DSOURCE_PATH_SIZE = $ {SOURCE_PATH_SIZE}")  

В исходном коде определите __ FILEN макрос, который просто добавляет размер исходного пути к макросу __ FILE__ :

  #define __FILENAME__ (__FILE__ + SOURCE_PATH_SIZE)  

Тогда просто используйте этот новый макрос вместо макроса __ FILE__ . Это работает, потому что путь __ FILE__ всегда начинается с пути к вашему исходному каталогу CMake. Удалив его из строки __ FILE__ , препроцессор позаботится об указании правильного имени файла, и все это будет относиться к корню вашего проекта CMake.

Если вы заботитесь о производительности, это так же эффективно, как использование __ FILE__ , потому что оба __ FILE__ и SOURCE_PATH_SIZE известны компиляцией константы времени, поэтому компилятор может их оптимизировать.

Единственное место, где это не сработает, — это если вы используете это для сгенерированных файлов, а они находятся в папке сборки вне исходного кода . Тогда вам, вероятно, придется создать другой макрос, используя переменную CMAKE_BUILD_DIR вместо CMAKE_SOURCE_DIR .

6


Здесь чисто временное решение компиляции. Он основан на том факте, что sizeof () строкового литерала возвращает его длину + 1.

  #define STRIPPATH (s)  (  sizeof (s)> 2 && (s) [sizeof (s) -2] == '/'? (s) + sizeof (s) - 1:  sizeof (s)> 3 && (s) [sizeof (s)  ) -3] == '/'? (S) + sizeof (s) - 2:  sizeof (s)> 4 && (s) [sizeof (s) -4] == '/'? (S) +  sizeof (s) - 3:  sizeof (s)> 5 && (s) [sizeof (s) -5] == '/'? (s) + sizeof (s) - 4:  sizeof (s)> 6  && (s) [sizeof (s) -6] == '/'? (s) + sizeof (s) - 5:  sizeof (s)> 7 && (s) [sizeof (s) -7] ==  '/'? (s) + sizeof (s) - 6:  sizeof (s)> 8 && (s) [sizeof (s) -8] == '/'? (s) + sizeof (s) - 7  :  sizeof (s)> 9 && (s) [sizeof (s) -9] == '/'? (s) + sizeof (s) - 8:  sizeof (s)> 10 && (s) [sizeof  (s) -10] == '/'? (s) + sizeof (s) - 9:  sizeof (s)> 11 && (s) [sizeof (s) -11] == '/'? (s  ) + sizeof (s) - 10: (s)) # define __JUSTFILE__ STRIPPATH (__ FILE__)  

Не стесняйтесь расширять каскад условных операторов до максимально разумного имени файла в проекте . Длина пути не имеет значения, если вы проверяете достаточно далеко от конца строки.

Я посмотрю, смогу ли я получить аналогичный макрос без жестко заданной длины с рекурсией макросов …

2


По крайней мере, для gcc значение __ FILE__ — это путь к файлу , указанный в командной строке компилятора . Если вы компилируете file.c следующим образом:

  gcc -c/full/path/to/file.c  

__ FILE__ будет расширяться до "/full/path/to/file.c" . Если вы вместо этого сделаете это:

  cd/full/path/togcc -c file.c  

, затем __ FILE__ будет расширяться только до "file.c" .

Это может оказаться практичным, а может и не оказаться.

Стандарт C не требует такого поведения. Все, что он говорит о __ FILE__ , это то, что он расширяется до «Предполагаемое имя текущего исходного файла (литерал символьной строки)».

Альтернативой является использование директива #line . Он отменяет текущий номер строки и, возможно, имя исходного файла. Если вы хотите переопределить имя файла, но оставить номер строки в покое, используйте макрос __ LINE__ .

Например, вы можете добавить это в верхней части file.c :

  #line __LINE__ "file.c"  

Единственная проблема при этом он присваивает указанный номер строки следующей строке , а первый аргумент #line должен быть цифрой -sequence , чтобы вы не могли сделать что-то вроде

  #line (__LINE __- 1) "file.c"//Это неверно  

Проверка того, что имя файла в директиве #line совпадает с фактическим именем файла, оставлена ​​в качестве упражнения.

На по крайней мере для gcc, это также повлияет на имя файла, указанное в диагностических сообщениях.

3


GCC 8 теперь имеет -fmacro-prefix-map и -ffile-prefix-map :

-fmacro-prefix-map = old = new

При предварительной обработке файлов, находящихся в каталоге old , разверните Макросы __FILE__ и __ BASE_FILE__ , как если бы файлы находились в каталоге new . Это можно использовать для изменения абсолютного пути на относительный путь с помощью . для new , что может привести к более воспроизводимым построениям, не зависящим от местоположения. Этот параметр также влияет на __ builtin_FILE () во время компиляции. См. Также -ffile-prefix-map.

-ffile-prefix-map = old = new

При компиляции файлов, находящихся в каталоге old , записывайте любые ссылки на них в результате компиляции, как если бы файлы вместо этого находились в каталоге new . Указание этого параметра эквивалентно указанию всех отдельных параметров -f * -prefix-map . Это можно использовать для создания воспроизводимых сборок, не зависящих от местоположения. См. Также -fmacro-prefix-map и -fdebug-prefix-map.

Установка недопустимого путь для -ffile-prefix-map ( -fdebug-prefix-map ) прервет отладку, если вы не укажете отладчику, как выполнить обратное отображение. (gdb: set substitue-path , vscode: "sourceFileMap" ).

Если вы намерены только очистить __ FILE__ просто используйте -fmacro-prefix-map .

Пример: так для моего Jenkins я добавлю -ffile-prefix-map = $ {WORKSPACE}/=/ и еще одну, чтобы удалить префикс установки локального пакета разработчика.

ПРИМЕЧАНИЕ. К сожалению, параметры -ffile-prefix-map и -fmacro-prefix-map доступны только в GCC 8 вперед. Например, для GCC 5 у нас есть только -fdebug-prefix-map , который не влияет на __ FILE__ .

1


  • C ++ 11
  • msvc2015u3, gcc5.4, clang3.8.0

      шаблон  inline constexpr size_t get_file_name_offset (const T (&  str) [S], size_t i = S - 1) {return (str [i] == '/' || str [i] == '\')?  i + 1: (i> 0? get_file_name_offset (str, i - 1): 0);} шаблон  inline constexpr size_t get_file_name_offset (T (& str) [1]) {return 0;}   

      int main () {printf ("% s  n", & __ FILE __ [get_file_name_offset (__ FILE __)]);}  

Код генерирует смещение времени компиляции, когда:

  • gcc : хотя бы gcc6.1 + -O1
  • msvc : поместить результат в переменную constexpr:

      constexpr auto file = & __ FILE __ [get_file_name_offset (__ FILE__)];  printf ("% s  n", file);  
  • clang : сохраняется не во время компиляции оценка

Есть трюк, заставляющий все 3 компилятора выполнять оценку времени компиляции даже в конфигурации отладки с отключенной оптимизацией:

  утилита пространства имен {template  struct const_expr_value {static constexpr const T value = v;  };  } #define UTILITY_CONST_EXPR_VALUE (exp) :: utility :: const_expr_value  :: value int main () {printf ("% s  n", & __ FILE __ [UTILITY_CONST_EXPR_VALUE (get_file_name_offset) (__)  }  

https://godbolt.org/z/u6s8j3

1


Я уже много лет использую одно и то же решение с ответом @Patrick.

Возникает небольшая проблема, когда полный путь содержит символ-ссылку.

Лучшее решение.

  set  (CMAKE_C_FLAGS "$ {CMAKE_C_FLAGS} -Wno-builtin-macro-redefined -D '__ FILE __ = " $ (subst $ (realpath $ {CMAKE_SOURCE_DIR})/,, $ (abspath $  

Зачем это нужно?

  • -Wno-builtin-macro-redefined , чтобы отключить предупреждения компилятора для переопределения макроса __ FILE__ .

    Если компиляторы не поддерживают это, см. Надежный способ ниже.

  • Удаление пути к проекту из пути к файлу — ваш реальный требование. Вам не захочется тратить время на то, чтобы узнать, где находится файл header.h , src/foo/header.h или src/bar/header.h .

  • Мы должны удалить макрос __ FILE__ в cmake config.

    Этот макрос используется в большинстве существующих кодов. Просто переопределите его, и вы освободитесь.

    Компиляторы, такие как gcc , предопределяют этот макрос из аргументов командной строки. И полный путь записан в файлах makefile , сгенерированных cmake.

  • Требуется жесткий код в CMAKE _ * _ FLAGS .

    Есть несколько команд для добавления параметров или определений компилятора в некоторые более поздние версии , например add_definitions () и add_compile_definitions () . Эти команды будут анализировать функции make, такие как subst , прежде чем применять их к исходным файлам. Мы этого не хотим.

Надежный способ для -Wno-builtin-macro-redefined .

включают (CheckCCompilerFlag) check_c_compiler_flag (-Wno встроенная_команда_оболочки-макро-переопределены SUPPORT_C_WNO_BUILTIN_MACRO_REDEFINED), если (SUPPORT_C_WNO_BUILTIN_MACRO_REDEFINED) множество (CMAKE_C_FLAGS «$ {} CMAKE_C_FLAGS -Wno встроенная_команда_оболочки-макро-переопределена») ENDIF (SUPPORT_C_WNO_BUILTIN_MACRO_REDEFINED) включают (CheckCXXCompilerFlag) check_cxx_compiler_flag (-Wno встроенная_команда_оболочки-макро-переопределены SUPPORT_CXX_WNO_BUILTIN_MACRO_REDEFINED), если (SUPPORT_CXX_WNO_BUILTIN_MACRO_REDEFINED) множество (CMAKE_CXX_FLAGS «$ {} CMAKE_CXX_FLAGS -Wno встроенная_команда_оболочки-макро-переопределена») ENDIF (SUPPORT_CXX_WNO_BUILTIN_MACRO_REDEFINED) код>

Не забудьте удалить этот параметр компилятора из строки set (* _ FLAGS ... -D__FILE __ = ...) .

4


В VC при использовании /FC , __ FILE__ расширяется до полного пути, без параметра /FC __ FILE__ расширяет имя файла. ссылка: здесь

1


Это невозможно сделать во время компиляции. Очевидно, вы можете сделать это во время выполнения, используя среду выполнения C, как показали некоторые другие ответы, но во время компиляции, когда срабатывает предварительный процессор, вам не повезло.

6


Используйте функцию basename () или, если вы работаете в Windows, _splitpath ().

  #include  #define PRINTFILE () {char buf [] = __FILE__;  printf ("Имя файла:% s  n", базовое имя (buf));  }  

Также попробуйте man 3 basename в оболочке.

5


Если вы используете CMAKE с компилятором GNU, это global define работает нормально:

  set (CMAKE_CXX_FLAGS "$ {CMAKE_CXX_FLAGS} -D__MY_FILE __ = '" $ (notdir $ (abspath $  


Небольшое изменение того, что предлагает @ red1ynx, могло бы создать следующий макрос:

  #define SET_THIS_FILE_NAME ()  static const char * const THIS_FILE_NAME =  strrchr (  __ФАЙЛ__, '/') ?  strrchr (__ FILE__, '/') + 1: __FILE__;  

В каждый из ваших файлов .c (pp) добавьте:

  SET_THIS_FILE_NAME ();  

Затем вы можете ссылаться на THIS_FILE_NAME вместо __ FILE__ :

  printf ("% s  n", THIS_FILE_NAME);  

Это означает, что построение выполняется один раз для каждого файла .c (pp) вместо каждой ссылки на макрос.

Его можно использовать только из файлов .c (pp), и его нельзя будет использовать из файлов заголовков.

0


Я сделал макрос __ FILENAME__ , который позволяет каждый раз не обрезать полный путь. Проблема заключается в том, чтобы сохранить полученное имя файла в локальной переменной cpp.

Это легко сделать, определив статическую глобальную переменную в файле .h . Это определение дает отдельные и независимые переменные в каждом .cpp файл, который включает .h . Чтобы обеспечить многопоточность, стоит сделать переменные также локальными потоками (TLS).

Одна переменная хранит имя файла (в сжатом виде). Другой содержит необрезанное значение, которое дал __ FILE__ . Файл h:

  static __declspec (thread) const char * fileAndThreadLocal_strFilePath = NULL; static __declspec (thread) const char * fileAndThreadLocal_strFileName = NULL;  

Сам макрос вызывает метод со всей логикой:

  #define __FILENAME__  GetSourceFileName (__ FILE__, fileAndThreadLocal_strFilePath, fileAndThreadLocal_strFileName)  

И функция реализована так:

  const char * GetSourceFileName (const char * strFilePath, const char * & rstrFilePathHolder, const char * & rstrFileNameHolder) {if  (strFilePath! = rstrFilePathHolder) {////Это работает в двух случаях://- при первом вызове в cpp (обычный случай) или//- когда макрос __FILENAME__ используется как в h, так и в cpp файлах// и поэтому метод последовательно вызывается//один раз с strFilePath == "UserPath/HeaderFileThatUsesMyMACRO.h" и//один раз с strFilePath == "UserPath/CPPFileThatUsesMyMACRO.cpp"//rstrFileNameHolder = removePath (  strFilePath);  rstrFilePathHolder = strFilePath;  } return rstrFileNameHolder;}  

removePath () может быть реализован по-разному, но быстрый и простой, похоже, достигается с помощью strrchr:

  const char * removePath (const char * path) {const char * pDelimeter = strrchr (path, '\');  если (pDelimeter) путь = pDelimeter + 1;  pDelimeter = strrchr (путь, '/');  если (pDelimeter) путь = pDelimeter + 1;  путь возврата;}  


Последний компилятор Clang имеет макрос __ FILE_NAME__ (см. здесь).


просто надеюсь немного улучшить макрос FILE:

#define FILE (strrchr ( __FILE__, '/')? Strrchr (__ FILE__, '/') + 1: strrchr (__ FILE__, '\')? Strrchr (__ FILE__, '\') + 1: __FILE__)

это улавливает/и , как просил Чарек Томчак, и это отлично работает в моей смешанной среде.

2


Попробуйте

  #pragma push_macro ("__ FILE __") # define __FILE__ "foobar  .c " 

после операторов include в исходном файле e и добавьте

  #pragma pop_macro ("__ FILE__")  

в конец исходного файла.

2


Вот переносимая функция, которая работает как для Linux (путь ‘/’) и Windows (сочетание » и ‘/’).
Компилируется с помощью gcc, clang и vs.

  #include  #include  const char * GetFileName (const char * path) {const char * name = NULL, * tmp = NULL;  если (путь && * путь) {имя = strrchr (путь, '/');  tmp = strrchr (путь, '\');  if (tmp) {вернуть имя && имя> tmp?  имя + 1: tmp + 1;  }} возвращаемое имя?  имя + 1: путь;} int main () {const char * name = NULL, * path = NULL;  путь = __FILE__;  name = GetFileName (путь);  printf ("путь:% s, имя файла:% s  n", путь, имя);  путь = "/tmp/device.log";  name = GetFileName (путь);  printf ("путь:% s, имя файла:% s  n", путь, имя);  path = "C: \ Downloads \ cris.avi";  name = GetFileName (путь);  printf ("путь:% s, имя файла:% s  n", путь, имя);  путь = "C: \ Downloads/nda.pdf";  name = GetFileName (путь);  printf ("путь:% s, имя файла:% s  n", путь, имя);  путь = "C:/Загрузки \ word.doc";  name = GetFileName (путь);  printf ("путь:% s, имя файла:% s  n", путь, имя);  путь = NULL;  имя = GetFileName (NULL);  printf ("путь:% s, имя файла:% s  n", путь, имя);  путь = "";  имя = GetFileName ("");  printf ("путь:% s, имя файла:% s  n", путь, имя);  return 0;}  

Стандартный вывод:

  путь: test.c, имя файла: test.cpath:/tmp/device  .log, имя файла: устройство.logpath: C:  Downloads  cris.avi, имя файла: cris.avipath: C:  Downloads/nda.pdf, имя файла: nda.pdfpath: C:/Downloads  word.doc, имя файла:  word.docpath: (null), filename: (null) path:, filename:  


Вот решение, которое использует вычисление времени компиляции:

  constexpr auto * getFileName (const char * const path) {const auto * startPosition  = путь;  for (const auto * currentCharacter = path; * currentCharacter! = ' 0'; ++ currentCharacter) {if (* currentCharacter == '\' || * currentCharacter == '/') {startPosition = currentCharacter;  }} если (startPosition! = путь) {++ startPosition;  } return startPosition;} std :: cout  


Если вы оказались на этой странице в поисках способа удалить абсолютный исходный путь, указывающий на некрасивое место сборки из двоичного файла, который вы отправляете, то приведенное ниже может удовлетворить ваши потребности.

Хотя это не дает точного ответа на то, что автор выразил свое желание , так как предполагается использование CMake , он довольно близок. Жаль, что об этом раньше никто не упомянул, так как это сэкономило бы мне кучу времени.

  OPTION (CMAKE_USE_RELATIVE_PATHS "Если это правда, cmake будет использовать относительные пути" ON)   

Установка для указанной выше переменной значения ON приведет к созданию команды сборки в формате:

  cd /ugly/absolute/путь/к/проекту/build/src && gcc  -c ../../src/path/to/source.c

В результате макрос __ FILE__ разрешится в ../../src/path/to/source.c

Документация CMake

Остерегайтесь предупреждение на странице документации:

Используйте относительные пути (может не работать!).

Работа не гарантируется во всех случаях, но работал в моем — CMake 3.13 + gcc 4.5

1


Поскольку вы используете GCC, вы можете воспользоваться преимуществами

__ BASE_FILE__ Этот макрос расширяется до имя основного входного файла в виде строковой константы C. Это исходный файл, который был указан в командной строке препроцессора или компилятора C

, а затем контролировать, как вы хотите отображать имя файла, изменяя представление исходного файла (полный путь /относительный путь/базовое имя) во время компиляции.

4


Вот решение, которое работает для сред, в которых нет строковой библиотеки (ядро Linux, встроенные системы и т. д.):

  #define FILENAME ({ const char * filename_start = __FILE__;   const char * filename = filename_start;  while (* filename! = ' 0')  filename ++;  while ((filename! = filename_start) && (* (filename - 1)! = '/'))  filename-  -;  filename;})  

Теперь просто используйте FILENAME вместо __ FILENAME__ . Да, это все еще среда выполнения, но она работает.

1


  #include  #include  using namespace std; string f (__FILE__); f = string ((find (f.rbegin (), f.rend (), '/') + 1)  .base () + 1, f. end ());//ищет '/' сзади, переводит обратный итератор//в прямой итератор и создает новую строку с обоими  


Краткий рабочий ответ для Windows и * nix:

  #define __FILENAME__ std :: max  (__ FILE __,  std :: max (strrchr (__ FILE__, '\') + 1, strrchr (__ FILE__, '/'  ) +1))  

1


Измененный, еще более «раздутая» версия ответа red1ynx:

  #define __FILENAME__  (strchr (__ FILE__, '\') ? ((strrchr (__ FILE__, '\'  )? strrchr (__ FILE__, '\') + 1: __FILE__)) : ((strrchr (__ FILE__, '/')? strrchr (__ FILE__, '/') + 1: __FILE__)))  

Если мы находим обратную косую черту, мы разбиваем на обратную косую черту. В противном случае разделите на косую черту. Достаточно просто.

Практически любая альтернатива была бы чище (на мой взгляд, C ++ constexpr действительно является здесь золотым стандартом). Однако это может быть полезно, если вы используете какой-либо компилятор, в котором __ BASE_FILE__ недоступен.



Первые шаги с ROOT

Перед использованием ROOT его необходимо успешно установлен, и все переменные среды должны быть заданы. → См. Руководство по установке.

В частности, рекомендуется поместить следующую команду в .profile или .login , чтобы переменные среды правильно определялись при каждом входе в систему.

  source/path /to/install-or-build/dir/bin/thisroot.sh  

Запуск и завершение сеанса ROOT

Запуск ROOT

Вы запускаете ROOT в системной подсказке.

Введите в системной подсказке:

  $ root  

Приглашение ROOT не отображается сыграно.

  ------------------------  ------------------------------------------ |  Добро пожаловать в ROOT 6.22/02 https://root.cern |  |  (c) 1995-2020, Команда ROOT;  концепция: Р. Брун, Ф. Радемакерс |  |  Создано для macosx64 17 августа 2020 г., 12:46:52 |  |  Из тегов/v6-22-02 @ v6-22-02 |  |  Попробуйте '.help', '.demo', '.license', '.credits', '.quit'/'. Q' |  --------------------------------------------------  ---------------- root [0]  

Чтобы увидеть список команд ROOT, введите :

  .help  

Список команд ROOT отображается.

  Использование метакоманд Cling (интерпретатор C/C ++) Всем командам должен предшествовать символ '.', за исключением оператора оценки  {} ================================================  ============================== Синтаксис: .Command [arg0 arg1 ... argN] .L  - загрузить  заданный файл или библиотеку. (x | X)  [args] - То же, что .L, запускает функцию с сигнатурой: ret_type filename (args).>  - Перенаправить команду в указанный файл '>' или '  1> '- Перенаправляет только поток stdout' 2> '- Перенаправляет только поток stderr' &> '(или' 2> & 1 ') - Перенаправляет как stdout, так и stderr' >> '- Добавляется в указанный файл .undo [  n] - выгружает последние n входных строк .U  - выгружает заданный файл .I [путь] - показывает путь включения.  Если указан путь - добавляет путь к путям включения .O  - устанавливает уровень оптимизации (0-3) (еще не реализован) .class  - выводит класс  в CINT-подобном формате  style .files - Распечатывает некоторую CINT-подобную статистику файлов .fileEx - Распечатывает некоторую статистику файлов .g - Распечатывает информацию о глобальной переменной 'name' - если имя не указано, распечатайте их все. @ - Отменяет и игнорирует многострочность  input .rawInput [0 | 1] - Включает перенос и печать результатов выполнения входных данных .dynamicExtensions [0 | 1] - Включает использование динамических областей и позднего связывания .printDebug [0 | 1] - Включает печать  соответствующие изменения состояния входа .storeState  - сохранить состояние интерпретатора в заданном файле .compareState  - сравнить состояние интерпретатора с сохраненным в заданном файле .stats [name] - показать статистику для внутренних структур данных 'ast  'статистика абстрактного синтаксического дерева' asttree [фильтр] 'макет абстрактного синтаксического дерева' decl 'дамп объявлений ast' un  do 'show undo stack .help - Показывает эту информацию. q - Выход из программы Специальные команды ROOT. ==============================  ============================================ .pwd: показать текущий каталог  , pad и стиль .ls: список содержимого текущего каталога .which [file]: показывает путь к файлу макроса .help Class: открывает справочное руководство для этого класса .help Class :: Member: открывает справочное руководство для функции/члена  

Запуск ROOT с параметрами командной строки

Инструменты командной строки ROOT

ROOT также предоставляет множество инструментов командной строки в командной строке для простых операций с файлами или автоматизации общих операций, выполняемых над классами ROOT. → См. Инструменты командной строки ROOT

Вы можете запустить ROOT со следующими параметрами командной строки:

-b : ROOT-сессия работает в пакетном режиме, без графического отображения. Этот режим полезен, если вы не хотите устанавливать ДИСПЛЕЙ..

-n : не выполняет сценарий входа в систему и сценарий выхода, как указано в .rootrc .

-q : завершает работу после обработки файлов макросов командной строки.

-l : не показывает Баннер ROOT.

-a : показывает заставку ROOT.

-x : Завершается при исключении.

dir : если dir является допустимым каталогом, перейдите в него (cd) перед выполнением ROOT .

-? , -h , - help : выводит использование.

-config : выводит параметры ./configure .

-memstat : запускает ROOT с мониторингом использования памяти.

Выход из ROOT

Введите в командной строке ROOT:

.q

Использование интерактивного интерпретатора C ++ Cling

ROOT использует интерактивный интерпретатор C ++ Cling, который построен на основе L ow L ng> evel V irtual M achine (LLVM) и библиотеки Clang. Cling предоставляет командную строку и JIT-компилятор для компиляция.
Для получения дополнительной информации о Cling, → см. Cling.

При использовании интерактивного интерпретатора Cling, в отличие от чистого языка C ++, точка с запятой (; ) в конце строки не требуется.

Simple команды

Вы можете использовать ROOT для выполнения простых команд в приглашении ROOT. Каждая команда, вводимая в приглашении ROOT, сохраняется в файле .root_hist в вашем домашнем каталоге .

Примеры

Простые операции:

   root [0] 21 + 21 (int) 42  
  root [1] sqrt (42) 6.4807407  

Операторы отношения:

  root [2] 42> 98 false  

Вызов функции из ROOT класс вроде TMath :: Pi .

  root [3] Math :: Pi () 3.1415927  

Многострочные команды

Вы можете использовать ROOT для выполнения многострочных команд на приглашение ROOT.

  1. Чтобы начать многострочную команду, введите в приглашении ROOT: {

  2. Введите по одной команде в каждой строке.

  3. Чтобы завершить многострочную команду, введите: }

  root [0] {root [1] Int_t j = 0;  корень [2] для (Int_t i = 0; i  

Вы также можете поместить команды в файле, так называемый ROOT-макрос, а затем выполнить и скомпилировать его. Для получения дополнительной информации о макросах ROOT → см. Макросы ROOT и общие библиотеки

Регулярные выражения

В регулярных выражениях можно использовать следующие метасимволы:

ˆ : привязка к началу строки.

$ : привязка к концу строки.

. : соответствует любому символу.

[: запускает класс символов.

] : завершение класса символа.

ˆ : отменяет класс символа, если первый символ .

* : закрытие Клини (соответствует 0 или более).

+ : Положительное закрытие (1 или более).

? : необязательное закрытие (0 или 1).

При использовании подстановочных знаков Предполагается, что регулярному выражению предшествует ˆ (BOL) и заканчивается $ (EOL).

Все * (закрытие) стоит . , это любой символ, кроме косой черты /. Его особая обработка позволяет легко сопоставлять имена путей.

Пример

*. root будет соответствовать aap.root , но не pipo/aap.root

escape-символы:

: обратная косая черта.

b : Backspace.

f : подача формы.

n : новая строка.

r : возврат каретки.

s : пробел.

t : табуляция.

e : символ ASCII ESC (‘033’).

DDD : число, состоящее из 1-3 восьмеричных цифр.

xDD : число, состоящее из 1-2 шестнадцатеричных цифр.

ˆC : C = любая буква. Управляющий код.

Вы можете использовать класс TRegexp для создания регулярного выражения из входной строки. Если подстановочный знак истинен, то входная строка содержит подстановочное выражение.

Пример

  TRegexp (const char * re, подстановочный знак Bool_t)  

Регулярное выражение и подстановочные знаки можно легко использовать в таких методах, как:

Ssiz_t Index (const TString & string, Ssiz_t * len, Ssiz_t i) const

Метод находит первое вхождение регулярного выражения в строке и возвращает его позицию.

Использование команд Cling для управления ROOT

Вы можете передавать команды напрямую в ROOT, поставив точку перед командой.

Введите в строке ROOT:

 .   

.q : выход из ROOT.

.? : предоставляет список всех команд.

.! : обращается к оболочке операционной системы. Например, .! Ls или .! Pwd .

.x : Выполняет ROOT-макрос.

.U : выгружает файл.

. L : загружает ROOT-макрос или библиотеку.

. L + : компилирует ROOT-макрос.

.help : предоставляет список всех команд.

.class : перечисляет доступные классы ROOT.

.class X : показывает, что cling знает о классе X .

.files : показывает все загруженные файлы.

. include : показывает пути включения.

.I path : добавляет путь включения.

.printAST : показывает абстрактное синтаксическое дерево после каждого обработанного объекта.

Учебники по ROOT

Учебник ROOT — это макрос ROOT, который демонстрирует специфичный для ROOT функции.

При установке ROOT создается каталог tutorials , содержащий все руководства ROOT, перечисленные на странице руководства Справочного руководства.

Для выполнения руководств вам необходимы права на запись в каталог tutorials .

Начиная с hsimple.C

Рекомендуется ed, чтобы сначала начать с макроса hsimple.C . Он создает ROOT-файл hsimple.root , который используется многими другими макросами. hsimple.root содержит четыре гистограммы hpx , hpx; 1 , hpxpy; 1 и hprof; 1 .

Для получения подробной информации о файлах ROOT см. → Файлы ROOT.

Чтобы выполнить макрос hsimple.C в приглашении ROOT введите:

  root [0] .x hsimple.C  

Выполнение демонстраций с помощью demos.C

В макросе demos.C доступно множество демонстраций.

Чтобы выполнить макрос demos.C в приглашении ROOT, введите:

  root [0] .x demos.C  

Откроется окно. Здесь вы можете опробовать различные демонстрации.

Исходный код руководств по ROOT

Чтобы проверить исходный код макроса ROOT, откройте его в своем любимом текстовом редакторе.

Учебное пособие по graph.C из $ ROOTSYS/ учебные пособия/графики

  void graph () {TCanvas * c1 = new TCanvas ("c1", "Пример простого графика", 200,10,700,500);  c1-> SetGrid ();  const Int_t n = 20;  Double_t x [n], y [n];  для (Int_t я = 0; я  SetLineColor (2);  gr-> SetLineWidth (4);  gr-> SetMarkerColor (4);  gr-> SetMarkerStyle (21);  gr-> SetTitle («простой график»);  gr-> GetXaxis () -> SetTitle ("X заголовок");  gr-> GetYaxis () -> SetTitle ("Y заголовок ");  gr-> Draw ("ACP"); //TCanvas :: Update () рисует фрейм, после чего его можно изменить c1-> Update ();  c1-> GetFrame () -> SetBorderSize (12);  c1-> Изменено ();  }  

Оцените статью
clickpad.ru
Добавить комментарий