Авто скомпилировать псевдоним в .bashrc

TL; DR: использовать make filename вместо этого. Рассмотрите установку и экспорт CXXFLAGS для предупреждений.

Если Вы действительно только интересуетесь выполнением g++ -o filename filename.cpp (без опций включить предупреждения компилятора или иначе настроить поведение компилятора), можно считать просто первый раздел, сразу ниже. Для покрытия альтернативных подходов, которые действительно используют псевдонимы оболочки и окружают функции, посмотрите самый последний раздел.

Этот ответ внимание на C++, но большую часть его относится к C. Существенное различие то, что флаги make передачи для компиляции файла исходного кода C взяты от CFLAGS вместо CXXFLAGS.

---

Можно просто передать базовое имя make.

Как steeldriver говорит, лучшее решение, чем функция оболочки или псевдоним оболочки состоят в том, чтобы использовать в своих интересах makeнеявные правила. Выполнение Вашей команды g++ -o filename filename.cpp имеет тот же эффект как

make filename

... если filename существует и является не более старым, чем filename.cpp, в этом случае make рефрены от компиляции его снова и вместо этого сообщают make: 'filename' is up to date, который является тем, что Вы, вероятно, хотите в той ситуации. При изменении файла исходного кода это становится более новым, чем скомпилированный в последний раз исполняемый файл (если таковые имеются), таким образом, последующий вызов make filename перекомпилировал его.

Как steeldriver упомянутый, у Вас должен только быть один файл исходного кода с filename как его базовое имя для использования этого метода. Если у Вас есть файлы исходного кода для нескольких языков, как filename.c, filename.cpp, и filename.m, затем make выберет один согласно его правилам, и это не обязательно будет то, которое Вы предназначаете.

Выполнение make без make-файла также только работает, если Ваша программа только требует одного файла исходного кода. Но это, кажется, имеет место здесь и также чаще всего имеет место, когда каждый начинает обучение программировать в C или C++.

Команда make на самом деле выполнения для компиляции файла исходного кода C++ не на самом деле g++, но вместо этого c++. Однако c++ на Ubuntu (и большинство систем GNU/Linux) обычно символьная ссылка, которая решает к g++ команда, если Вы сознательно не изменили его или только установили некоторый другой компилятор C++.

Необходимо включить предупреждения и обычно выбирать диалект.

За очень немногими исключениями, такими как проверка, что Ваш компилятор работает вообще, необходимо включить предупреждения компилятора. Это говорит Вашему компилятору предупреждать Вас о коде, который, вероятно, будет содержать ошибки. По умолчанию, большая часть C и компиляторы C++, включая популярные компиляторы GCC и Лязг ( g++ и clang++ команды), предупреждают об очень немногих вещах. Я опишу, как работать g++ с включенными предупреждениями затем я покажу, как сделать make включите предупреждения, когда Вы будете работать make filename.

В минимуме использовать -Wall, который по историческим причинам и вопреки его имени на самом деле не включает всем предупреждениям. Необходимо также почти всегда использовать -Wextra. Можно включить дополнительные предупреждения индивидуально (выполненный man g++ видеть всех их, если Вам нравится), но это - хорошее начало и часто разумный выбор даже для большого проекта программного обеспечения.

Я не знаю, сколько опыта C++ Вы в настоящее время имеете. Опытные программисты обычно используют и извлекают выгоду значительно из предупреждений, но если Вы плохо знакомы с языком, Вы все еще не должны ожидать, чтобы начать использовать их. Это вызвано тем, что они могут сохранить Вас много головной боли в нахождении в других отношениях раздражающих ошибок в Ваших программах, и потому что они могут помочь Вам постараться не делать частые ошибки и разрабатывать дурные привычки.

Команда g++ -o filename filename.cpp не просит никого, но небольшое количество предупреждений по умолчанию. Соответствующая команда g++ -Wall -Wextra -o filename filename.cpp включает -Wall и -Wextra. Можно поместить -Wall и -Wextra где угодно в команде кроме между -o и filename или прежде g++.

Если Вы хотите испытать -Wall и -Wextra одно время, можно работать make как это:

make CXXFLAGS='-Wall -Wextra' filename

Обратите внимание, что это все еще не перекомпилирует filename.cpp если исходный код является не более новым, чем исполняемый файл, даже если Вы не передали CXXFLAGS='-Wall -Wextra' кому: make в прошлый раз Вы выполнили его.

Как Вы видите, это является довольно громоздким; Ваша целая цель состоит в том, чтобы скомпилировать Ваши небольшие программы с минимумом ввода. К счастью, в дополнение к принятию присвоений на CXXFLAGS переменная на командной строке, make также отношения CXXFLAGS переменная среды, если существует тот. Таким образом, можно работать

export CXXFLAGS='-Wall -Wextra'

и затем последующие выполнения make filename передаст -Wall и -Wextra флаги к компилятору C++ автоматически. Однако это не является постоянным; в других оболочках (которые не запускаются от этого) это не применяется.

Я доберусь до того, как можно избежать необходимости вводить это скоро. Но сначала...

Необходимо выбрать диалект и рассмотреть -pedantic для большего количества предупреждений.

Необходимо также сказать g++ какой диалект C++ Вы используете. Например, если Вы используете C++ 17 без расширений GNU, передаете -std=c++17 опция. С этой записи C++ 17 является текущим стандартным диалектом C++. Если Вы изучаете C++, и Вы не уверены, какой диалект Вы хотите, Вы могли консультироваться с любыми материалами, из которых Вы извлекаете уроки или консультируетесь со своим преподавателем (если таковые имеются). Если ничего подобного не применяется, я предлагаю использовать текущий стандарт, предполагая, что Ваш компилятор поддерживает его. Сообщение компилятора -std=c++17 не вынуждает Вас использовать все новейшие функции C++ в Ваших программах. Если бы Вы хотите C++ 17 с расширениями GNU, Вы использовали бы -std=gnu++17; если Вы не знаете или заботитесь о различии, то -std=c++17 разумно.

Если Вы не говорите g++ какой диалект Вы хотите, он будет использовать свое значение по умолчанию, которое варьируется через различные версии GCC. Определение диалекта, который Вы хотите, помогает ошибкам проблемы компилятора и предупреждениям, когда Ваш код является неправильным (или подозрительным), когда он считается записанным на том конкретном диалекте. Это также помогает компилятору не выпустить ошибки и предупреждения, которые не могли бы подходить для диалекта, который Вы используете, потому что без него, компилятор предполагает, что Вы используете то, что его значение по умолчанию.

Если Вы говорите g++ какой диалект Вы хотите, и это - один из стандартных диалектов (например, если Вы используете -std=c++17, нет -std=gnu++17), затем можно включить больше предупреждений, чем было бы иначе показано о коде, который не соответствует тому диалекту путем передачи g++ -pedantic флаг. Некоторые из тех предупреждений на самом деле относятся ко всем или самым стандартным диалектам. Если Вы хотите, чтобы такой код заставил ошибки быть выпущенными - то, чтобы заставлять компилятор сознательно перестать работать и отказаться генерировать исполняемый файл, даже если это иначе могло - затем можно использовать -pedantic-errors.

Можно передать те флаги, даже если Вы не делаете конкретный диалект или если диалект, который Вы указываете, не является тем те, который стандартизирован, но Вы, вероятно, не хотели бы, потому что будет трудно судить, разумны ли они, и Вы, вероятно, закончили бы тем, что игнорировали многие из них. Можно также превратить все предупреждения в ошибки с -Werror, который является несколько популярной практикой, потому что она лишает возможности игнорировать предупреждения. Однако, если Вы только начинаете, я предлагаю против выполнения этого, даже при том, что предупреждения не должны быть проигнорированы кроме чрезвычайно необычных случаев. Иногда удобно заставить код компилировать с предупреждениями, испытывать его и затем решать проблемы, которые вызвали предупреждения.

Включать -std=c++17 и -pedantic в Вашем CXXFLAGS:

export CXXFLAGS='-std=c++17 -pedantic -Wall -Wextra'

Если Вы уже экспортировали CXXFLAGS в Вашей оболочке можно опустить export на последующих присвоениях. Но нет никакого вреда в хранении его.

Можно поместить Ваш export команда в файле, затем получите его с ..

Можно установить CXXFLAGS путем Вы установили бы большинство переменных среды, как PATH, например, путем помещения export команда для него в ~/.profile. Но я рекомендую против этого, потому что можно создать программное обеспечение с make это было записано другими авторами, для который Ваш обычно предпочтительный CXXFLAGS не хороший выбор.

Вместо этого я предлагаю делать файл, который содержит export CXXFLAGS='...' команда (с Вашими фактическими флагами вместо ...) такой как один показанный выше. Затем когда Вы хотите выполнить ту команду, можно избежать необходимости вводить ее путем определения источника того файла с . встроенный. Если файл называют cxxflags и находится в Вашем корневом каталоге:

. ~/cxxflags

Как то, если Вы работали export управляйте вручную, Вы только имеете к этому однажды в Вашей оболочке. Все Ваше последующее make команды будут использовать новое значение CXXFLAGS, до Вас exit из текущей оболочки. make команда, выполненная на отдельных сессиях оболочки, однако, таких как те, которые в других терминалах, не будет затронута.

Обратите внимание, что это не ситуация, куда необходимо работать chmod +x на файле и выполненный это просто пишущий ~/cxxflags. Это не сделало бы то, что Вы хотите, потому что это присвоило бы и экспортировало бы CXXFLAGS переменная среды в оболочке начала запускать скрипт, который сразу выйдет впоследствии, и среда текущей оболочки была бы незатронута.

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

---

Для будущего...

Несколько неудачно, как сложный это должно эффективно скомпилировать программы C++ из командной строки, знать, какой диалект Вы используете и получаете довольно полезные предупреждения. (IDE имеют соответствующие, даже перекрывающиеся проблемы..., но это не делает ситуацию командной строки легкой для пользователей, которые еще не довольны ею.), Хотите верьте, хотите нет, флаги, которые я предложил здесь, являются просто теми, я рекомендую новое использование программистов на C++ со дня один.

Если у Вас уже есть некоторый опыт C++ (даже немного), можно хотеть сделать больше. Не стесняйтесь игнорировать остальную часть этого раздела!

-g испускает отладочные символы; затем можно использовать отладчик как gdb отлаживать Вашу программу. При предыдущем использовании IDE он, возможно, уже скомпилировал программы таким образом и интегрировался с отладчиком. (Можно интегрировать IDE с отладчиком в Ubuntu и существует несколько вариантов, но это выходит за рамки этого сообщения.)

Флаги, которые запускаются -O призыв к оптимизации; наиболее распространенные -Og, для оптимизации, которая обычно не мешает отладке; -O1, для очень консервативной оптимизации; -O2, для большей части оптимизации скорости; -O3 пытаться отжать еще больше скорости, которая иногда помогает и иногда не делает; и -Os, оптимизировать для пространства, а не скорости. Сборки отладки C и программ C++ обычно используют или оптимизацию или -Og, в то время как сборки конечных версий обычно используют -O2, -O3, или -Os.

Сборки отладки часто извлекают выгоду из дезинфицирующих средств, которые ловят и объясняют проблемы, которые иначе вызвали бы запутывающий катастрофический отказ или тонкое неправильное поведение. -fsanitize=address,undefined часто полезно. Хотя это - точно вид вещи, я хотел бы рекомендовать людям, которые плохо знакомы с C или C++ (или кто прибывает из платформ, которые дезинфицирующие средства еще не поддерживают), я постарался не предлагать это выше, потому что это иногда представляет дополнительную сложность. В некоторых системах дополнительные пакеты должны быть установлены для поддержки их; поведение по умолчанию Дезинфицирующего средства Адреса состоит в том, чтобы распечатать сообщения об утечках памяти, когда программа выходит, даже если утечки были приемлемы потому что программа, сознательно вырученная во время ошибки; при вхождении в компиляцию программ с несколькими файлами исходного кода при компиляции их отдельно (как make-файл сделал бы), необходимо передать -fsanitize=... в разовое ссылкой, а также время компиляции; они являются несовместимыми с некоторыми библиотеками, с которыми Вы могли бы связаться и использовать из своего кода; и они являются несовместимыми, или требуют, чтобы дополнительное усилие использовалось, с некоторыми другими инструментами, включая некоторые отладчики.

Для пути, путь больше предложений инструментов, см. эту главу cppbestpractices.

Псевдонимы и функции Shell

Вы спросили о псевдониме. Можно создать псевдоним оболочки, если Вы действительно хотите. Но это не может сделать то, что Вы хотите. Псевдонимы в ударе не принимают аргументы; они просто расширяются в их определения. Можно записать аргументы после них в команде, но они появляются в конце, где Вы записали им. Вы ничем не можете заменить в определение псевдонима, таким образом, Вы не можете вызвать аргумент filename появиться в нем вместо некоторого другого текста. Поэтому waltinator продемонстрировал функцию оболочки вместо этого. Функции Shell намного более мощны и универсальны, чем псевдонимы оболочки.

После этих слов Вы хотели бы иметь псевдоним как это:

alias mk='make CXXFLAGS="-std=c++17 -pedantic -Wall -Wextra"'

Это - альтернатива экспорту CXXFLAGS как описано выше. После того как то определение псевдонима было выполнено, можно работать mk filename создавать filename.cpp с теми флагами компилятора. Если Вы предпочитаете этот подход, я предлагаю вставить определение псевдонима .bash_aliases в Вашем корневом каталоге (создают файл, если он не делает). Значение по умолчанию, в расчете на пользователя .bashrc источники файла .bash_aliases если это существует, таким образом, в новых интерактивных оболочках удара, псевдоним будет определен.

Или возможно Вы хотите определить CXXFLAGS но используйте функцию оболочки в качестве способом waltinator выполнить компиляцию с теми флагами:

compile() { g++ $CXXFLAGS -o "$1" "$1.cpp"; }

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

Или можно включать флаги, которые Вы хотите в самом функциональном определении:

compile() { g++ -std=c++17 -pedantic -Wall -Wextra -o "$1" "$1.cpp"; }

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

compile() { g++ -o "$1" "$1.cpp"; }