Leonardo IDE
Это IDE на базе Macintosh, компилятор и отладчик для программ на C. Он включает в себя редактор с подсветкой синтаксиса, ANSI C компилятор, компилятор для языка визуализации ALPHA, редактор графов, обратимый виртуальный процессор и т. д.
Обратите внимание, что программы в код, который будет выполняться для виртуального ЦПУ. Виртуальная машина и отладчик позволяют выполнять код вперед и назад и поддерживать многозадачность
IDE поставляется с анимированными алгоритмами, примерами исходного кода таких игр, как Tetris, Checkers и других. IDE полезна для проверки и отладки исходного кода, поиска процессов, неэффективно использующих память и т. д.
Примечание: этот проект был прекращен.
Пример: объявление удаленного препроцессора
Эта ошибка может возникать, если вы ссылаетесь на функцию или переменную, которая находится в коде, скомпилированном по условию, который не компилируется для текущей конфигурации. Это также может произойти при вызове функции в файле заголовка, который в настоящее время не поддерживается в среде сборки. Если определенные переменные или функции доступны только при определении конкретного макроса препроцессора, убедитесь, что код, вызывающий эти функции, может быть скомпилирован только при определении одного и того же макроса препроцессора. Эту ошибку легко выявить в интегрированной среде разработки, так как объявление функции недоступно, если требуемые макросы препроцессора не определены для текущей конфигурации сборки.
Это пример кода, который работает при сборке в отладке, но не в розницу:
Интерпретатор C / C++ Ch Embeddable (стандартная версия)
Интерпретатор C / C++, поддерживающий стандарт ISO 1990 C (C90), основные функции C99, классы C++, а также расширения к языку С, такие как вложенные функции, строковый тип и т. д. Он может быть встроен в другие приложения и аппаратные средства, использоваться в качестве языка сценариев. Код C / C++ интерпретируется напрямую без компиляции промежуточного кода. Поскольку этот интерпретатор поддерживает Linux, Windows, MacOS X, Solaris и HP-UX, созданный вами код можно перенести на любую из этих платформ. Стандартная версия бесплатна для личного, академического и коммерческого использования. Для загрузки пакета необходимо зарегистрироваться.
Оптимизации в .NET
В .NET-модели компиляции компоновщик не участвует. Но есть компилятор исходного кода (компилятор C#) и JIT-компилятор. Компилятор исходного кода выполняет только небольшие оптимизации. Например, он не занимается подстановкой функций и оптимизациями циклов. Эти оптимизации берет на себя JIT-компилятор. JIT-компилятор, входящий во все версии .NET Framework вплоть до 4.5 включительно, не поддерживает SIMD-инструкции. Но JIT-компилятор в .NET Framework 4.5.1 и более поздних версиях, называемый RyuJIT, такие инструкции поддерживает.
В чем разница между RyuJIT и Visual C++ в плане возможностей оптимизации? Поскольку он делает свою работу в период выполнения, RyuJIT может осуществлять оптимизации, на которые не способен Visual C++. Например, в период выполнения RyuJIT может определить, что условие в выражении if никогда не будет true в данном конкретном сеансе работы приложения, и поэтому соответственно оптимизировать его. Кроме того, RyuJIT использует преимущества возможностей процессора, на котором он выполняется. Скажем, если процессор поддерживает SSE4.1, JIT-компилятор сгенерирует только инструкции SSE4.1 для функции sumOfcubes, благодаря чему сгенерированный код получится гораздо более компактным. Однако он не имеет возможности тратить много времени на оптимизацию кода, потому что время JIT-компиляции сказывается на производительности приложения. С другой стороны, компилятор Visual C++ может потратить гораздо больше времени для обнаружения других возможностей оптимизации и задействовать их преимущества. Отличная новая технология от Microsoft, называемая .NET Native, позволяет компилировать управляемый код в самодостаточные исполняемые файлы, оптимизируемые с помощью блока окончательной обработки компилятора Visual C++. В настоящее время эта технология поддерживается только для приложений Windows Store.
Возможность контролировать оптимизации управляемого кода пока что весьма ограниченная. Компиляторы C# и Visual Basic позволяют лишь включать или выключать оптимизации ключом /optimize. Для контроля JIT-оптимизаций можно применять атрибут System.Runtime.CompilerServices.MethodImpl к какому-либо методу с указанием варианта из MethodImplOptions. Вариант NoOptimization отключает оптимизации, NoInlining запрещает подстановку метода, а AggressiveInlining (.NET 4.5) выдает рекомендацию (а не просто подсказку) JIT-компилятору подставить метод.
Идентификатор не объявлен
Если идентификатор является переменной или именем функции, его необходимо объявить перед тем, как его можно будет использовать. Перед использованием функции в объявлении функции также должны быть включены типы его параметров. Если переменная объявлена с помощью , компилятор должен иметь возможность определить тип из его инициализатора.
Если идентификатор является членом класса или структуры или объявлен в пространстве имен, он должен уточняться именем класса или структуры или именем пространства имен при использовании вне структуры, класса или области пространства имен. Кроме того, пространство имен должно быть помещено в область с помощью директивы, такой как , или имя члена должно быть помещено в область с помощью объявления, такого как . В противном случае неполное имя считается необъявленным идентификатором в текущей области.
Если идентификатор является тегом для определяемого пользователем типа, например, или , тип тега должен быть объявлен до его использования. Например, объявление должно существовать, прежде чем можно будет объявить переменную в коде.
Если идентификатор является псевдонимом типа, тип должен быть объявлен с помощью объявления или перед тем, как его можно будет использовать. Например, необходимо объявить, прежде чем можно будет использовать в качестве псевдонима типа для .
Освобождение памяти с помощью free
Теперь рассмотри, как происходит освобождение памяти. Переменная указатель хранит адрес области памяти,
начиная с которого она может им пользоваться.
Однако, она не хранит размера этой области. Откуда тогда функция free знает, сколько памяти необходимо освободить?
Очевидно, что информация о размере выделенного участка должна где-то храниться. Есть несколько решения этой проблемы.
- 1. Можно создать карту, в которой будет храниться размер выделенного участка. Каждый раз при освобождении памяти компьютер будет обращаться к этим данным и получать нужную информацию.
- 2. Второе решение более распространено. Информация о размере хранится на куче до самих данных. Таким образом, при выделении памяти резервируется места больше и туда записывается информация о выделенном участке. При освобождении памяти функция free «подсматривает», сколько памяти необходимо удалить.
Утечка памяти
Динамически выделенная память не имеет области видимости, т.е. она остается выделенной до тех пор, пока не будет явно освобождена или пока ваша программа не завершит свое выполнение (и операционная система очистит все буфера памяти самостоятельно). Однако указатели, используемые для хранения динамически выделенных адресов памяти, следуют правилам области видимости обычных переменных. Это несоответствие может вызвать интересное поведение, например:
void doSomething()
{
int *ptr = new int;
}
|
1 |
voiddoSomething() { int*ptr=newint; } |
Здесь мы динамически выделяем целочисленную переменную, но никогда не освобождаем память через использование оператора delete. Поскольку указатели следуют всем тем же правилам, что и обычные переменные, то, когда функция завершит свое выполнение, выйдет из области видимости. Поскольку — это единственная переменная, хранящая адрес динамически выделенной целочисленной переменной, то, когда уничтожится, больше не останется указателей на динамически выделенную память. Это означает, что программа «потеряет» адрес динамически выделенной памяти. И в результате эту динамически выделенную целочисленную переменную нельзя будет удалить.
Это называется утечкой памяти. Утечка памяти происходит, когда ваша программа теряет адрес некоторой динамически выделенной части памяти (например, переменной или массива), прежде чем вернуть её обратно в операционную систему. Когда это происходит, то программа уже не может удалить эту динамически выделенную память, поскольку больше не знает, где выделенная память находится. Операционная система также не может использовать эту память, поскольку считается, что она по-прежнему используется вашей программой.
Утечки памяти «съедают» свободную память во время выполнения программы, уменьшая количество доступной памяти не только для этой программы, но и для других программ также. Программы с серьезными проблемами с утечкой памяти могут «съесть» всю доступную память, в результате чего ваш компьютер будет медленнее работать или даже произойдет сбой. Только после того, как выполнение вашей программы завершится, операционная система сможет очистить и вернуть всю память, которая «утекла».
Хотя утечка памяти может возникнуть и из-за того, что указатель выходит из области видимости, возможны и другие способы, которые могут привести к утечкам памяти. Например, если указателю, хранящему адрес динамически выделенной памяти, присвоить другое значение:
int value = 7;
int *ptr = new int; // выделяем память
ptr = &value; // старый адрес утерян — произойдет утечка памяти
|
1 |
intvalue=7; int*ptr=newint;// выделяем память ptr=&value;// старый адрес утерян — произойдет утечка памяти |
Это легко решается удалением указателя перед операцией переприсваивания:
int value = 7;
int *ptr = new int; // выделяем память
delete ptr; // возвращаем память обратно в операционную систему
ptr = &value; // переприсваиваем указателю адрес value
|
1 |
intvalue=7; int*ptr=newint;// выделяем память delete ptr;// возвращаем память обратно в операционную систему ptr=&value;// переприсваиваем указателю адрес value |
Кроме того, утечка памяти также может произойти и через двойное выделение памяти:
int *ptr = new int;
ptr = new int; // старый адрес утерян — произойдет утечка памяти
|
1 |
int*ptr=newint; ptr=newint;// старый адрес утерян — произойдет утечка памяти |
Адрес, возвращаемый из второго выделения памяти, перезаписывает адрес из первого выделения. Следовательно, первое динамическое выделение становится утечкой памяти!
Точно так же этого можно избежать удалением указателя перед операцией переприсваивания.
Пример: предварительно скомпилированный заголовок не является первым
Эта ошибка может возникать, если вы поместили директивы препроцессора, такие как #include, #define или #pragma, перед #includeом предкомпилированного файла заголовка. Если исходный файл использует предварительно скомпилированный заголовочный файл (то есть если он компилируется с помощью параметра компилятора /Yu ), то все директивы препроцессора перед файлом предкомпилированного заголовка будут проигнорированы.
Этот пример не удается скомпилировать , поскольку и определены в <> заголовке iostream, который игнорируется, так как он включается перед предкомпилированным файлом заголовка. Чтобы выполнить сборку этого примера, создайте все три файла, а затем скомпилируйте файл stdafx. cpp, а затем скомпилируйте C2065_pch. cpp.
Чтобы устранить эту проблему, добавьте #include < iostream > в файл предкомпилированного заголовка или переместите его после включения файла предкомпилированного заголовка в исходный файл.
Пример: отсутствует заголовочный файл
Вы не включили заголовочный файл, объявляющий идентификатор. Убедитесь, что файл, содержащий объявление идентификатора, включен в каждый исходный файл, который его использует.
Другая возможная причина заключается в том, что при использовании списка инициализаторов не включается <> заголовок initializer_list.
эта ошибка может возникать в исходных файлах Windows классических приложений, если вы определяете , или . Эти макросы препроцессора исключают некоторые файлы заголовков из Windows. h и afxv_w32. h для ускорения компиляции. Просмотрите Windows. h и afxv_w32. h, чтобы получить последние сведения о том, что исключено.
Пример. Использование неограниченного идентификатора
Эта ошибка может возникать, если идентификатор не является правильно заданной областью. Если вы видите C2065 при использовании , это является причиной. Если функции и операторы стандартной библиотеки C++ не полностью определены в пространстве имен или вы не передали пространство имен в текущую область с помощью директивы, компилятор не сможет их найти. Чтобы устранить эту проблему, необходимо либо полностью определить имена идентификаторов, либо указать пространство имен с помощью директивы.
Этот пример не компилируется , поскольку и определены в пространстве имен:
Идентификаторы, объявляемые внутри типов, или, также должны уточняться именем их включающей области при их использовании за пределами этой области.
malloc
В предыдущей главе уже обсуждалось, что локальные переменные кладутся на стек и существую до тех пор, пока мы не вышли из функции.
С одной стороны, это позволяет автоматически очищать память, с другой стороны, существует необходимость в переменных, время жизни которых мы можем контролировать
самостоятельно. Кроме того, нам необходимо динамическое выделение памяти, когда размер используемого пространства заранее не известен. Для этого используется
выделение памяти на куче. Недостатков у такого подхода два: во-первых, память необходимо вручную очищать, во-вторых, выдеение памяти – достаточно дорогостоящая операция.
Для выделения памяти на куче в си используется функция malloc (memory allocation) из библиотеки stdlib.h
void * malloc(size_t size);
Функция выделяет байтов памяти и возвращает указатель на неё. Если память выделить не удалось, то функция возвращает NULL.
Так как malloc возвращает указатель типа void, то его необходимо явно приводить к нужному нам типу. Например, создадим указатель, после этого выделим память размером в 100 байт.
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
void main() {
int *p = NULL;
p = (int*) malloc(100);
free(p);
}
После того, как мы поработали с памятью, необходимо освободить память функцией free.
Используя указатель, можно работать с выделенной памятью как с массивом. Пример: пользователь вводит число – размер массива, создаём массив этого размера и заполняем
его квадратами чисел по порядку. После этого выводим и удаляем массив.
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
void main() {
const int maxNumber = 100;
int *p = NULL;
unsigned i, size;
do {
printf("Enter number from 0 to %d: ", maxNumber);
scanf("%d", &size);
if (size < maxNumber) {
break;
}
} while (1);
p = (int*) malloc(size * sizeof(int));
for (i = 0; i < size; i++) {
p = i*i;
}
for (i = 0; i < size; i++) {
printf("%d ", p);
}
_getch();
free(p);
}
Разбираем код
p = (int*) malloc(size * sizeof(int));
Здесь – приведение типов. Пишем такой же тип, как и у указателя. – сколько байт выделить. – размер одного элемента массива.
После этого работаем с указателем точно также, как и с массивом. В конце не забываем удалять выделенную память.
Теперь представим на рисунке, что у нас происходило. Пусть мы ввели число 5.
Выделение памяти.
Функция malloc выделила память на куче по определённому адресу, после чего вернула его. Теперь указатель p хранит этот адрес и может
им пользоваться для работы. В принципе, он может пользоваться и любым другим адресом.
Когда функция malloc «выделяет память», то она резервирует место на куче и возвращает адрес этого участка. У нас будет гарантия, что компьютер не отдаст нашу память кому-то ещё.
Когда мы вызываем функцию free, то мы освобождаем память, то есть говорим компьютеру, что эта память может быть использована кем-то другим.
Он может использовать нашу память, а может и нет, но теперь у нас уже нет гарантии, что эта память наша. При этом сама переменная не зануляется, она
продолжает хранить адрес, которым ранее пользовалась.
Это очень похоже на съём номера в отеле. Мы получаем дубликат ключа от номера, живём в нём, а потом сдаём комнату обратно. Но дубликат ключа у нас остаётся.
Всегда можно зайти в этот номер, но в нём уже кто-то может жить. Так что наша обязанность – удалить дубликат.
Иногда думают, что происходит «создание» или «удаление» памяти. На самом деле происходит только перераспределение ресурсов.
Microsoft Visual Studio Community
Для индивидуальных или начинающих программистов Microsoft Visual Studio Community включает в себя много важных инструментов из коммерческих версий проекта. Вы получите в свое распоряжение IDE, отладчик, оптимизирующий компилятор, редактор, средства отладки и профилирования. С помощью этого пакета можно разрабатывать программы для настольных и мобильных версий Windows, а также Android. Компилятор C++ поддерживает большинство функций ISO C++ 11, некоторые из ISO C++ 14 и C++ 17. В то же время компилятор C уже безнадежно устарел и не имеет даже надлежащей поддержки C99.
Программное обеспечение также поставляется с поддержкой построения программ на C#, Visual Basic, F# и Python. В то время, когда я писал эту статью, на сайте проекта утверждалось, что Visual Studio Community 2015 «бесплатный инструмент для индивидуальных разработчиков, проектов с открытым исходным кодом, научных исследований, образовательных проектов и небольших профессиональных групп».
realloc
Ещё одна важная функция – realloc (re-allocation). Она позволяет изменить размер ранее выделенной памяти и получает в качестве аргументов старый
указатель и новый размер памяти в байтах:
void* realloc(void* ptr, size_t size)
Функция realloc может как использовать ранее выделенный участок памяти, так и новый
При этом не важно, меньше или больше новый размер – менеджер памяти сам решает,
где выделять память.
Пример – пользователь вводит слова. Для начала выделяем под слова массив размером 10
Если пользователь ввёл больше слов, то изменяем его размер, чтобы хватило места.
Когда пользователь вводит слово end, прекращаем ввод и выводим на печать все слова.
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TERM_WORD "end"
#define SIZE_INCREMENT 10
void main() {
//Массив указателей на слова
char **words;
//Строка, которая используется для считывания введённого пользователем слова
char buffer;
//Счётчик слов
unsigned wordCounter = 0;
//Длина введённого слова
unsigned length;
//Размер массива слов. Для уменьшения издержек на выделение памяти
//каждый раз будем увеличивать массив слов не на одно значение, а на
//SIZE_INCREMENT слов
unsigned size = SIZE_INCREMENT;
int i;
//Выделяем память под массив из size указателей
words = (char**) malloc(size*sizeof(char*));
do {
printf("%d: ", wordCounter);
scanf("%127s", buffer);
//Функция strcmp возвращает 0, если две строки равны
if (strcmp(TERM_WORD, buffer) == 0) {
break;
}
//Определяем длину слова
length = strlen(buffer);
//В том случае, если введено слов больше, чем длина массива, то
//увеличиваем массив слов
if (wordCounter >= size) {
size += SIZE_INCREMENT;
words = (char**) realloc(words, size*sizeof(char*));
}
//Выделяем память непосредственно под слово
//на 1 байт больше, так как необходимо хранить терминальный символ
words = (char*) malloc(length + 1);
//Копируем слово из буффера по адресу, который
//хранится в массиве указателей на слова
strcpy(words, buffer);
wordCounter++;
} while(1);
for (i = 0; i < wordCounter; i++) {
printf("%s\n", words);
}
_getch();
for (i = 0; i < wordCounter; i++) {
free(words);
}
free(words);
}
Хочу обратить внимание, что мы при выделении памяти пишем sizeof(char*), потому что размер указателя на char не равен одному байту, как размер переменной типа char.
Определение оптимизаций кода компилятором
Оптимизация — это процесс преобразования части кода в другую функционально эквивалентную часть для улучшения одной или более характеристик кода. Две самые важные характеристики — это скорость работы и размер кода. К другим характеристикам относятся энергопотребление, необходимое для выполнения кода, время компиляции кода и — в случае, если конечный код требует JIT-компиляции, — длительность JIT-компиляции.
Компиляторы постоянно совершенствуются в отношении методов, применяемых ими для оптимизации кода. Но они не идеальны. Тем не менее, вместо траты на ручную оптимизацию программы гораздо продуктивнее использовать специфические средства компилятора и дать ему возможность оптимизировать код.
Существует четыре способа, помогающих компилятору оптимизировать ваш код более эффективно.
- Пишите понятный, простой в сопровождении код. Не рассматривайте объектно-ориентированные средства Visual C++ как врагов производительности. Новейшая версия Visual C++ умеет сводить к минимуму соответствующие издержки, а иногда и полностью исключать их.
- Используйте директивы компилятора. Например, сообщите компилятору задействовать то соглашение по вызову функций, которое работает быстрее, чем предлагаемое по умолчанию.
- Применяйте встроенные в компилятор функции (intrinsic function). Встроенной называется особая функция, реализация которой автоматически предоставляется компилятором. Компилятор знает о такой функции все и заменяет ее вызов чрезвычайно эффективной последовательностью инструкций, использующих преимущества целевой ISA. В настоящее время Microsoft .NET Framework не поддерживает встроенные функции, поэтому они не поддерживаются ни одним из управляемых языков. Однако Visual C++ имеет обширную поддержку этого функционала. Заметьте: хотя применение встроенных функций может повысить производительность кода, оно ухудшает его читаемость и портируемость.
- Используйте оптимизацию на основе профиля (profile-guided optimization, PGO). С помощью этого метода компилятор больше узнает о том, как будет вести себя код в период выполнения, и сможет соответственно оптимизировать его.
Цель этой статьи — показать, почему вы можете доверять компилятору, продемонстрировав оптимизации, которые выполняются над неэффективным, но читаемым кодом (с применением первого метода). Кроме того, я дам краткое введение в оптимизацию на основе профиля и упомяну некоторые из директив компилятора, позволяющих вам более тонко оптимизировать некоторые части своего кода.
Методов оптимизации компилятором много: от простых преобразований, таких как свертывание констант (constant folding), до экстремальных преобразований вроде планирования выполнения команд (instruction scheduling). Однако в этой статье я ограничусь обсуждением некоторых из важнейших оптимизаций — тех, которые могут значительно повысить производительность (на десятки процентов) и уменьшить размер кода: замены вызовов телами функций (function inlining), оптимизаций COMDAT и оптимизаций циклов (loop optimizations). Первые два метода я рассмотрю в следующем разделе, а затем покажу, как контролировать оптимизации, выполняемые Visual C++. Наконец, я кратко поясню оптимизации в .NET Framework. На протяжении всей статьи я буду использовать Visual Studio 2013 для компиляции кода.
Управление оптимизациями
В дополнение к ключам /O1, /O2 и /Ox компилятора вы можете контролировать оптимизации для конкретных функций с помощью директивы optimize, которая выглядит так:
Список оптимизации может быть либо пустым, либо содержать одно или более из следующих значений: g, s, t и y. Они соответствуют ключам компилятора /Og, /Os, /Ot и /Oy.
Пустой список с параметром off приводит к отключению всех оптимизаций независимо от указанных ключей компилятора. Пустой список с параметром on вводит в действие заданные ключи компилятора.
Ключ /Og разрешает глобальные оптимизации. Если LTCG включен, ключ /Og разрешает WPO.
Директива optimize полезна, когда вы хотите, чтобы разные функции оптимизировались по-разному — некоторые для большей компактности, другие для увеличения скорости работы. Однако, если вам действительно нужен контроль такого уровня, вы должны подумать об оптимизации на основе профиля (profile-guided optimization, PGO). Это процесс оптимизации кода с применением профиля, содержащего информацию о поведении, которая была записана при выполнении оснащенной (средствами мониторинга и протоколирования) версии кода. Компилятор использует профиль для принятия более эффективных решений о том, как оптимизировать код. Visual Studio предоставляет необходимые инструменты для применения этого метода к управляемому и неуправляемому коду.
Вступление
Типичный компилятор выполняет следующие шаги:
- Разбор: исходный текст преобразуется в абстрактное синтаксическое дерево (AST).
- Разрешение ссылок на другие модули (C откладывает этот шаг до ссылки).
- Семантическая проверка: отсеивание синтаксически правильных утверждений, которые не имеют смысла, например недоступный код или дубликаты объявлений.
- Эквивалентные преобразования и оптимизация высокого уровня: AST преобразуется для представления более эффективных вычислений с той же семантикой. Это включает, например, раннее вычисление общих подвыражений и константных выражений, устраняя чрезмерные локальные назначения (см. также SSA ) и т. д.
- Генерация кода: AST преобразуется в линейный низкоуровневый код с переходами, распределением регистров и т. П. Некоторые вызовы функций могут быть встроены на этом этапе, некоторые циклы развернуты и т.д.
- Оптимизация глазка: низкоуровневый код сканируется для выявления простых локальных неэффективностей, которые устраняются.
Большинство современных компиляторов (например, gcc и clang) повторяют последние два шага еще раз. Они используют промежуточный низкоуровневый, но независимый от платформы язык для начальной генерации кода. Затем этот язык преобразуется в специфичный для платформы код (x86, ARM и т.д.), Что делает примерно то же самое оптимизированным для платформы способом. Это включает, например, использование векторных команд, когда это возможно, переупорядочение команд для повышения эффективности прогнозирования ветвлений и так далее.
После этого объектный код готов к связыванию. Большинство компиляторов нативного кода знают, как вызывать компоновщик для создания исполняемого файла, но сам по себе это не этап компиляции. В таких языках, как Java и C # ссылки могут быть полностью динамическими, что делается с помощью VM во время загрузки).
3 ответа
Лучший ответ
VLA могут быть использованы в «CMake Project», которые являются приложениями C ++. Создайте новый «CMake Project» вместо «Консольное приложение», а затем перейдите в Project в верхнем левом меню и выберите последний вариант (настройки CMake для ProjectName). Откроется файл JSON. Под опцией Toolset щелкните раскрывающееся меню, чтобы выбрать Clang.
Выше VS2019 16.1 Clang уже доступен. Если он недоступен, нажмите «Изменить» VS2019 в установщике Visual Studio и в «Средстве разработки C / C ++» выберите «Инструменты Clang для окон». Это установит Clang.
Поэтому главное — выбрать «Проект CMake» вместо «Консольное приложение», которое часто не отображается ни в одной инструкции. VLA теперь будут работать в файле .cpp, и Visual Studio 2019 можно будет использовать в качестве IDE для поддержки VLA.
1
Pera
20 Окт 2019 в 14:36
В зависимости от того, как я читаю это предложение, оно либо тавтологическое, либо бессмысленное. Да, нормальные вещи работают нормально, но массивы VLA «работают» в C ++ только в том смысле, что они не определены языком.
VLA определены C, и были в течение 20 лет. И да, многие компиляторы C — но не компиляторы C ++ — поддерживают их. Ярким исключением является компилятор Microsoft, которого нет. Он не соответствует стандарту C99 (не говоря уже о C11, C14 или C17). Можно сказать, что они немного позади. Похоже, их позиция заключается в том, что они будут реализовывать столько языка Си, сколько им удобно в контексте компилятора C ++. Те части C, которые не являются частью C ++, не подходят.
Это ясно: поддержание актуальности компилятора C не является приоритетом для Microsoft.
Простая правда в том, что если вы хотите работать в современном C, вы не можете использовать компилятор Microsoft. Возможно, вы сможете понять, как настроить IDE для использования компилятора GNU. Однако в какой-то момент вы можете начать спрашивать, стоит ли вам времени бороться с системой, столь враждебной вашим целям.
James K. Lowden
19 Окт 2019 в 21:36
Этот ответ о C ++.
Массив переменной длины не является стандартом ISO C ++, некоторые компиляторы принимают его как расширение. например gcc
Изменить
Такое расширение все еще может быть реализацией, если оно не ‘ изменить поведение правильно сформированной программы.
Если вы используете VLA, тогда ваш код не переносим, так как другие компиляторы могут иметь или не иметь такого расширения, и тот, который теперь может перестать работать, всякий раз, когда поставщик решает отказаться от поддержки.
Если вы не знаете размер во время компиляции и хотите использовать C ++, используйте {{ X0 } }. Вы можете просто изменить свой код на:
Однако, если вам нужно иметь VLA, вот список поддерживаемых компиляторов: Прямой эфир на godbolt (поддерживаются компиляторы с зеленой меткой)
MSVC нет в списке. Таким образом, вы можете использовать Clang в вашем VS. Вот учебное пособие. Или еще проще: вы можете использовать встроенную поддержку на VS2019 :
5
Oblivion
19 Окт 2019 в 21:20
Конфигурация Compile-Time Code Generation Release
Эта конфигурация похожа на конфигурацию Release, при которой оптимизации включены (задан ключ /O1, /O2 или /Ox компилятора), но ключ /GL компилятора не указан. При такой конфигурации полученные объектные файлы будут содержать оптимизированный двоичный код. Однако оптимизации на уровне всей программы не выполняются.
Изучая сгенерированный из source1.c файл листинга ассемблерного кода, вы заметите, что выполнены две оптимизации. Прежде всего первый вызов функции square — square(n) на рис. 1 — полностью исключен за счет оценки вычисления при компиляции. Как это произошло? Компилятор определил, что функция square компактна, поэтому нужно подставить ее тело в код вместо вызова. После этого компилятор определил, что значение локальной переменной n известно и не изменяется между оператором присваивания и вызовом функции. Поэтому он заключил, что можно безопасно выполнять умножение и подставить результат (25). При второй оптимизации второй вызов функции square — square(m) — тоже был заменен телом функции. Однако, поскольку значение m не известно при компиляции, компилятор не мог оценить вычисление и сгенерировал реальный код.
Теперь я посмотрю файл ассемблерного листинга, созданный из source2.c, который гораздо интереснее. Вызов функции cube в sumOfCubes был заменен телом функции. В свою очередь это позволило компилятору выполнить значительные оптимизации в цикле (как вы увидите в разделе «Оптимизации циклов»). Кроме того, в функции isPrime задействован набор инструкций SSE2 для преобразования из int в double при вызове функции sqrt, а также для преобразования double в int при возврате из sqrt. А sqrt вызывается лишь раз, когда начинается цикл. Заметьте: если компилятору не указывается ключ /arch, то x86-компилятор использует SSE2 по умолчанию. Большинство x86-процессоров, а также все процессоры x86-64 поддерживают SSE2.
Работа с двумерными и многомерными массивами
Для динамического создания двумерного массива сначала необходимо создать массив указателей, после чего каждому из элементов этого массива
присвоить адрес нового массива.
Для удаления массива необходимо повторить операцию в обратном порядке — удалить сначала подмассивы, а потом и сам массив указателей.
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#define COL_NUM 10
#define ROW_NUM 10
void main() {
float **p = NULL;
unsigned i;
p = (float**) malloc(ROW_NUM * sizeof(float*));
for (i = 0; i < ROW_NUM; i++) {
p = (float*) malloc(COL_NUM * sizeof(float));
}
//Здесь какой-то важный код
for (i = 0; i < ROW_NUM; i++) {
free(p);
}
free(p);
}
Сначала мы создаём массив указателей, а после этого каждому элементу этого массива присваиваем адрес вновь созданного массива. Это значит, что можно
- 1. Создавать массивы «неправильной формы», то есть массив строк, каждая из которых имеет свой размер.
- 2. Работать по отдельности с каждой строкой массива: освобождать память или изменять размер строки.
Создадим «треугольный» массив и заполним его значениями
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#define SIZE 10
void main() {
int **A;
int i, j;
A = (int**) malloc(SIZE * sizeof(int*));
for (i = 0; i < SIZE; i++) {
A = (int*) malloc((i + 1) * sizeof(int));
}
for (i = 0; i < SIZE; i++) {
for (j = i; j > 0; j--) {
A = i * j;
}
}
for (i = 0; i < SIZE; i++) {
for (j = i; j > 0; j--) {
printf("%d ", A);
}
printf("\n");
}
for (i = SIZE-1; i > 0; i--) {
free(A);
}
free(A);
_getch();
}
Чтобы создать трёхмерный массив, по аналогии, необходимо сначала определить указатель на указатель на указатель, после чего выделить память под массив указателей на указатель,
после чего проинициализировать каждый из массивов и т.д.
