Как определить размер моего массива в c?

Передача массива в функцию

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

• адрес массива,
• размер массива.

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

123456789101112131415161718192021222324252627282930313233343536373839404142

#define _CRT_SECURE_NO_WARNINGS#include <stdio.h>// Функция обменаvoid change(int *x, int n){  // x — указатель на массив (адрес массива)  // n — размер массива  int i;  int max, index;  max = x;  index = 0;  // Поиск максимального элемента  for (i = 1; i<n; i++)  {    if (x>max)    {      max = x;      index = i;    }  }  // Обмен  x = x;  x = max;}// Главная функцияint main(){  int a;  int i;  for (i = 0; i<10; i++)  {    printf(«a = «, i);    scanf(«%d», &a);  }  change(a, 10);  // вызов функции обмена          // Вывод элементов массива  for (i = 0; i<10; i++)    printf(«%d «, a);  getchar();  getchar();  return 0;}

Результат выполненияПример на Си Дан массив размерности n. Вычислить произведение четных элементов

12345678910111213141516171819202122232425262728293031

#define _CRT_SECURE_NO_WARNINGS#include <stdio.h>// Функция вычисления произведения чётных элементовint func(int *x, int n)  // произведение четных элементов{  int p = 1;  // начальное значение произведения  int i;  for (i = 0; i<n; i++)   {    if (x % 2 == 0)  // остаток от деления на 2 равен 0?      p = p * x;  }  return p;}// Главная функцияint main() {  int a; // объявлен массив a из 5 элементов  int i;  int pr;  // Ввод элементов массива  for (i = 0; i<5; i++)   {    printf(«a = «, i);    scanf(«%d», &a); // &a — адрес i-го элемента массива  }  pr = func(a, 5); // вычисление произведения  printf(«\n pr = %d», pr); // вывод произведения четных элементов  getchar();   getchar();  return 0;}

Результат выполнения

Язык Си

Размер элементов массива

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

Пример использования:

нуждается в этом значении в качестве третьего аргумента.

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

Обновление: libbsd предоставляет __arraycount():

Libbsd предоставляет макрос in , что небезопасно, потому что в нем отсутствует пара круглых скобок, но мы можем добавить эти скобки сами, и поэтому нам даже не нужно писать разделение в нашем заголовке (зачем нам дублировать код, который уже существует?). Этот макрос определен в системном заголовке, поэтому, если мы его используем, мы вынуждены использовать макросы, указанные выше.

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

Решение

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

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

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

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

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

Тем не менее, если вы уверены, что ваш индекс неотрицательный, то приведите его к не имеет никакого значения. C11 в 6.5.2.1 говорит (выделение мое):

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

13

Обновление: Разрешить использование макроса в области файла:

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

Кроме того, определение можно немного упростить.

Записи:

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

Я также использую следующую функцию C11. Однако его отсутствие при использовании более старого стандарта можно преодолеть с помощью некоторых грязных трюков (см., Например: Что такое “:-!!” в коде C? ).

_Static_assert()

Я также использую следующее расширение, но есть стандартный способ C сделать то же самое.

__VA_OPT__

Библиографический список

• Андрей Карпов. 64-битный конь, который умеет считать. http://www.viva64.comhttps://pvs-studio.com/ru/blog/posts/cpp/a0043/
• Андрей Карпов, Евгений Рыжков. 20 ловушек переноса Си++ — кода на 64-битную платформу. http://www.viva64.comhttps://pvs-studio.com/ru/blog/posts/cpp/a0004/
• Андрей Карпов. Безопасность 64-битного кода. http://www.viva64.comhttps://pvs-studio.com/ru/blog/posts/cpp/a0046/
• Андрей Карпов, Евгений Рыжков. Поиск ловушек в Си/Си++ коде при переносе приложений под 64-битную версию Windows. http://www.viva64.comhttps://pvs-studio.com/ru/blog/posts/cpp/a0012/
• Андрей Карпов, Евгений Рыжков. Разработка ресурсоемких приложений в среде Visual C++. http://www.viva64.comhttps://pvs-studio.com/ru/blog/posts/a0018/

Целочисленные типы фиксированной ширины

Чтобы облегчить кроссплатформенную переносимость, C99 определил набор целочисленных типов фиксированной ширины (в заголовочном файле stdint.h), которые гарантированно будут иметь одинаковый размер в любой архитектуре.

Они определены следующим образом:

Название	Тип	Диапазон значений	Примечание
	1 байт со знаком	от -128 до 127	Во многих системах обрабатывается как . Смотрите ниже.
	1 байт без знака	от 0 до 255	Во многих системах обрабатывается как . Смотрите ниже.
	2 байта со знаком	от -32 768 до 32 767
	2 байта без знака	от 0 до 65 535
	4 байта со знаком	— от -2 147 483 648 до 2 147 483 647
	4 байта без знака	от 0 до 4 294 967 295
	8 байт со знаком	от -9 223 372 036 854 775 808 до 9 223 372 036 854 775 807
	8 байт без знака	от 0 до 18 446 744 073 709 551 615

C++ официально принял эти целочисленные типы фиксированной ширины как часть стандарта C++11. К ним можно получить доступ, включив заголовочный файл cstdint, где они определены внутри пространства имен . Например:

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

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

Предупреждение

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

Конструкторы без параметров и инициализаторы полей

Начиная с C# 10 вы можете объявить конструктор экземпляра без параметров в типе структуры, как показано в следующем примере:

Как видно в примере выше, выражение значения по умолчанию игнорирует конструктор без параметров и создает для типа структуры значение по умолчанию, полученное путем присвоения значений по умолчанию всем полям типа значения (шаблон с нулевыми битами) и значения всем полям ссылочного типа. При создании экземпляра массива типа структуры также игнорируется конструктор без параметров и создается массив, заполненный значениями по умолчанию для типа структуры.

Начиная с C# 10 вы можете также инициализировать свойство или поле экземпляра в его объявлении, как показано в следующем примере:

Если вы не объявите конструктор без параметров явным образом, тип структуры предоставит стандартный конструктор без параметров со следующим поведением:

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

• Если тип структуры не имеет явных конструкторов экземпляров, но содержит инициализаторы полей, компилятор создает общедоступный конструктор без параметров, который выполняет указанные инициализации полей, как показано в следующем примере:

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

Дополнительные сведения см. в примечании к предложению новой возможности в разделе Конструкторы структур без параметров.

Неродные близнецы

Теперь рассмотрим работу с «динамическими» многомерными массивами, т.е. с массивами, память для которых выделяется динамически.

Создание и уничтожение динамических многомерных массивов

Как правило, работа с такими массивами осуществляется следующим образом:

(1) Для доступа к двумерному массиву объявляется переменная типа указатель на указатель на тип (в данном случае это указатель на указатель на ).

(2) Переменная инициализируется оператором , который выделяет память для массива указателей на .

(3) В цикле каждый элемент массива указателей инициализируется оператором , который выделяет память для массива типа .

Освобождение памяти происходит строго в обратном порядке: сначала уничтожаются массивы значений типа , а затем уничтожается массив указателей.

Работа с динамическим многомерным массивом синтаксически полностью совпадает с работой с многомерным C-массивом.

Пример кода для трёхмерного массива:

Где собака порылась

Работа с динамическим многомерным массивом синтаксически полностью совпадает с работой с многомерным C-массивом. (Цитирую предыдущий раздел.) Синтаксически — да, но между этими массивами есть глубокое различие, о котором начинающие программисты часто забывают.

Во-первых, для динамического массива выделяется другой объём памяти.

Если посчитать, сколько памяти будет выделяться для двумерного массива из примера выше, то получится: первый оператор выделил память для 3 указателей, второй оператор в цикле трижды выделил память для 5 элементов типа . Т.е. получилось, что выделили памяти для 15 значений типа и для 3 значений типа указатель на . Для C-массива компилятором была выделена память только для 15 значений типа . (Всяческие выравнивания и прочие оптимизации не учитываем!)

Во-вторых, память, выделенная для динамического массива, не непрерывна. Следовательно, хак №1 (обращение с двумерным массивом как с одномерным) работать не будет.

В-третьих, передача многомерных массивов в функции и работа с ними будет отличаться для динамических массивов и C-массивов.

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

Динамический многомерный массив НЕ является C-массивом.

Парадоксально, но факт, что наиболее близким родственничком для этих неродных близнецов, является хак №2, реализующий работу с многомерным массивом посредством одномерного массива (см. раздел Хаки). Все три вышеперечисленных различия для него неактуальны.

Стоит отметить, что массив указателей на массивы — структура более гибкая, чем двумерный C-массив. Например, для массива указателей на массивы размеры массивов могут быть разными, или какой-то массив может вообще отсутствовать. Наиболее распространённым примером является «массив строк», т.е. массив указателей на массивы типа (пример — см. в следующем разделе).

Ещё раз о предосторожности

Из вышеизложенного следует, что нужно чётко отличать многомерные C-массивы вида

от массивов указателей на массивы.

Иногда внешние отличия весьма незначительны. К примеру С-строка — это одномерный массив элементов типа , заканчивающийся нулевым байтом. Как реализовать массив строк?

Можно так:

Это — пример определения и инициализации двумерного C-массива

Каждая С-строка занимает ровно 10 байт, включая завершающий ноль (считаем, тип имеет размер 1 байт). Неиспользуемые байты у коротких строк, вроде «May», содержат «мусор» (или нули, если об этом позаботился компилятор). Весь массив занимает один непрерывный блок памяти размером 120 байт (12 строк по 10 символов).

А здесь определён и инициализирован одномерный (!) массив указателей на массивы элементов типа .

Вся информация, доступная через переменную , занимает 13 блоков памяти: массив из 12 указателей и 12 блоков памяти, адреса которых хранятся в указателях, содержащих С-строки с названиями месяцев. И нет никакой гарантии, что 12 блоков памяти с С-строками будут расположены в памяти последовательно и в порядке, соответствующем перечислению в инициализаторе.

Но в обоих случаях доступ к символу b в строке «February» будет осуществляться выражением .

И, в заключение, ещё одно предостережение.

Поскольку многомерные C-массивы, как правило, занимают большой объём памяти, их надо с особой осторожностью объявлять внутри функций, в том числе в. И с осторожностью в n-ной степени в рекурсивных функциях

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

Начальная инициализация массива.

Напишем простую программу. Создадим массив, после чего найдём его максимальный элемент.

#include <conio.h>
#include <stdio.h>

void main() {
	int a = {1, 2, 5, 3, 9, 6, 7, 7, 2, 4};
	unsigned i;
	int max;

	max = a;
	for (i = 1; i<10; i++) {
		if (a > max) {
			max = a;
		}
	}

	printf("max element is %d", max);
	getch();
}

Разберём пример. Сначала мы создаём массив и инициализируем его при создании. После этого присваиваем максимальному найденному элементу значение первого элемента массива.

	max = a;

После чего проходим по массиву. Так как мы уже просмотрели первый элемент (у него индекс 1), то нет смысла снова его просматривать.

Тот же пример, только теперь пользователь вводит значения

#include <conio.h>
#include <stdio.h>
 
void main() {
    int a;
    unsigned i;
    int max;
 
	printf("Enter 10 numbers\n");
	for (i = 0; i<10; i++) {
		printf("%d. ", i);
		scanf("%d", &a);
	}

    max = a;
    for (i = 1; i<10; i++) {
        if (a > max) {
            max = a;
        }
    }
 
    printf("max element is %d", max);
    getch();
}

В том случае, если при инициализации указано меньше значений, чем размер массива, остальные элементы заполняются нулями.

#include <conio.h>
#include <stdio.h>

void main() {
	int a = {1,2,3};
	unsigned i;

	for (i = 0; i<10; i++) {
		printf("%d ", a);
	}

	getch();
}

Если необходимо заполнить весь массив нулями, тогда пишем

int a = {0};

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

int a[] = {1, 2, 3};

массив будет иметь размер 3

Размер элементов массива

Первый из них очень простой, и не имеет значения, имеем ли мы дело с массивом или указателем, потому что это делается одинаково.

Пример использования:

требуется это значение в качестве третьего аргумента.

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

Переполнение массива

Пускай у вас есть такой код

int A;
int i;

for (i=0; i<=10; i++) {
	A = 1;
}

Здесь цикл for задан с ошибкой. В некоторых старых версиях компиляторов этот код зацикливался. Дело в том, что переменная i располагалась при
компиляции сразу за массивом A. При выходе за границы массива счётчик переводился в 1.
Массивы небезопасны, так как неправильная работа с индексом может приводить к доступу к произвольному участку памяти (Теоретически. Современные компиляторы сами заботятся о том, чтобы вы не копались в чужой памяти).

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

• 1. Используйте тип size_t для индексирования. Он обезопасит вас от отрицательных значений и его всегда хватит для массива любого размера.
• 2. Помните, что массив начинается с нуля.
• 3. Последний элемент массива имеет индекс (размер массива — 1)

Переменные

Данные хранятся в ячейках памяти компьютера. Когда мы вводим число, оно помещается в какую-то ячейку памяти. Но как потом узнать, куда именно? Как впоследствии обращаться к этим данными? Нужно как-то запомнить, пометить соответствующую ячейку.

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

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

Слово «переменная» обозначает, что сущность может меняться, она непостоянна. Действительно, вы увидите это в дальнейшем, одна и та же переменная может быть связана сначала с одними данными, а потом – с другими. То есть ее значение может меняться, она переменчива.

В программе на языке Python, как и на большинстве других языков, связь между данными и переменными устанавливается с помощью знака . Такая операция называется присваивание (также говорят «присвоение»). Например, выражение означает, что на объект, представляющий собой число 4, находящееся в определенной области памяти, теперь ссылается переменная sq, и обращаться к этому объекту следует по имени sq.

Имена переменных могут быть любыми. Однако есть несколько общих правил их написания:

1. Желательно давать переменным осмысленные имена, говорящие о назначении данных, на которые они ссылаются.

2. Имя переменной не должно совпадать с командами языка (зарезервированными ключевыми словами).

3. Имя переменной должно начинаться с буквы или символа подчеркивания (_), но не с цифры.

4. Имя переменной не должно содержать пробелы.

Чтобы узнать значение, на которое ссылается переменная, находясь в режиме интерпретатора, достаточно ее вызвать, то есть написать имя и нажать Enter.

>>> sq = 4
>>> sq
4

Вот более сложный пример работы с переменными в интерактивном режиме:

>>> apples = 100
>>> eat_day = 5
>>> day = 7
>>> apples = apples - eat_day * day
>>> apples
65

Здесь фигурируют три переменные: apples, eat_day и day. Каждой из них присваивается свое значение. Выражение сложное. Сначала выполняется подвыражение, стоящее справа от знака равенства. После этого его результат присваивается переменной apples, в результате чего ее старое значение (100) теряется. В подвыражении вместо имен переменных на самом деле используются их значения, то есть числа 100, 5 и 7.

Что такое std::size_t?

Рассмотрим следующий код:

На машине автора эта программа печатает:

Довольно просто, правда? Мы можем сделать вывод, что оператор возвращает целочисленное значение, но какой целочисленный тип у этого значения? ? ? Ответ заключается в том, что (и многие функции, возвращающие значение размера или длины) возвращают значение типа . определяется как целочисленный тип без знака и обычно используется для представления размера или длины объектов.

Забавно, но мы можем использовать оператор (который возвращает значение типа ), чтобы запросить размер самого :

Скомпилированная как 32-битное (4 байтовое) консольное приложение в системе автора данная программа выводит:

Подобно целочисленному типу, размер которого зависит от системы, размер также может быть разным. гарантированно является беззнаковым и имеет не менее 16 бит, но в большинстве систем будет эквивалентен ширине адреса в приложении. То есть для 32-разрядных приложений обычно будет 32-разрядным целочисленным типом без знака, а для 64-разрядного приложения обычно будет 64-разрядным целочисленным типом без знака. определяется достаточно большим, чтобы вместить размер самого большого объекта, созданного в вашей системе (в байтах). Например, если имеет ширину 4 байта, самый большой объект, создаваемый в вашей системе, не может быть больше 4 294 967 295 байтов, потому что это наибольшее число, которое может хранить 4-байтовое целое число без знака. Это только верхний предел размера объекта, реальный предел размера может быть ниже в зависимости от используемого компилятора.

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

Арифметическое переполнение и деление на нуль

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

Целочисленное арифметическое переполнение

Деление целого числа на ноль всегда вызывает исключение DivideByZeroException.

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

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

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

По умолчанию арифметические операции выполняются в непроверяемом контексте.

Арифметическое переполнение с плавающей запятой

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

Для операндов типа арифметическое переполнение всегда вызывает исключение OverflowException, а деление на нуль всегда вызывает исключение DivideByZeroException.

Размер элементов массива

Первый из них очень простой, и не имеет значения, имеем ли мы дело с массивом или указателем, потому что это делается одинаково.

Пример использования:

требуется это значение в качестве третьего аргумента.

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

6 ответов

Резюме:

Полный ответ:

Для определения размера массива в байтах можно использовать оператор:

На моем компьютере, ints 4 байта длиной, таким образом, n равняется 68.

Для определения числа элементов в массиве мы можем разделить общий размер массива размером элемента массива. Вы могли сделать это с типом, как это:

и получают надлежащий ответ (68 / 4 = 17), но если бы тип изменился, то у Вас была бы противная ошибка, если бы Вы забыли изменяться также.

, Таким образом, предпочтительный делитель , размер обнуляет элемент массива.

Другое преимущество состоит в том, что можно теперь легко параметризовать имя массива в макросе и добраться:

ответ дан einpoklum 28 February 2013 в 14:16

Википедия является неправильной, Skizz является правильным. sizeof (символ) равняется 1 по определению.

я имею в виду, просто читает статью в Википедии действительно тесно , чтобы видеть, что это неправильно. «кратные числа символа». никогда может быть ничто другой , чем «1». Если бы это было, скажем, 2, это означало бы, что был дважды размер символа!

ответ дан Peter Mortensen 28 February 2013 в 14:16

Magnus: стандарт определяет sizeof как получение числа байтов в объекте и что sizeof (символ) всегда один. Число битов в байте является конкретной реализацией.

Редактирование: стандарт C++ ANSI разделяет 5.3.3 Sizeof:

Раздел 1.6 модель памяти C++:

ответ дан Tim Cooper 28 February 2013 в 14:16

sizeof «прием» является лучшим способом, которым я знаю, с одним маленьким, но (мне, этот являющийся главным главным объектом неприязни) важное изменение в использовании круглой скобки. , Поскольку статья в Википедии ясно дает понять, C не является функцией; это оператор

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

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

Так: Если у Вас есть следующее:

можно найти число элементов с кодом как это:

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

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

всегда лучше использовать sizeof на фактическом объекте, когда Вы имеете один, а не на типе, с тех пор Вы не должны волноваться о совершении ошибки и утверждении неправильного типа.

, Например, скажите, что у Вас есть функция что выводы некоторые данные как поток байтов, например, через сеть. Давайте вызовем функцию и заставим ее взять в качестве аргументов указатель на объект отправить, и число байтов в объекте. Так, прототип становится:

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

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

Теперь Вы защищены. Несомненно, Вы копируете название переменной, но это имеет высокую вероятность повреждения способом, компилятор может обнаружить при изменении его.

ответ дан unwind 28 February 2013 в 14:16

Стоит отметить, что не помогает при контакте со значением массива, которое затухло к указателю: даже при том, что это указывает на запуск массива к компилятору, это совпадает с указателем на единственный элемент того массива. Указатель не «помнит» ничто больше о массиве, который использовался для инициализации его.

ответ дан Magnus Hoff 28 February 2013 в 14:16

ответ дан Ted Percival 28 February 2013 в 14:16

Другие вопросы по тегам:

Массивы

Пусть нам необходимо работать с большим количеством однотипных данных. Например, у нас есть тысяча измерений координаты маятника с каким-то
шагом по времени. Создавать 1000 переменных для хранения всех значений очень… обременительно. Вместо этого множество однотипных данных можно объединить под одним именем и
обращаться к каждому конкретному элементу по его порядковому номеру.

Массив в си определяется следующим образом
Например,
Мы получим массив с именем a, который содержит сто элементов типа int. Как и в случае с переменными, массив содержит мусор.

Для получения доступа до первого элемента, в квадратных скобках пишем его номер (индекс). Например

#include <conio.h>
#include <stdio.h>

void main() {

	int a;

	a = 10;
	a = 333;
	a = 234;
	printf("%d %d %d", a, a, a);

	getch();

}

Первый элемент имеет порядковый номер 0

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

Имя массива — это указатель на адрес памяти, где располагаются элементы массива.

Рис. 1 Массив хранит адрес первого элемента. Индекс i элемента — это сдвиг на i*sizeof(тип) байт от начала

Индекс массива указывает, на сколько байт необходимо сместиться относительно начала массива, чтобы получить доступ до нужно элемента.
Например, если массив A имеет тип int, то означает, что мы сместились на байт относительно начала.
Первый элемент находится в самом начале и у него смещение .

В си массив не хранит своего размера и не проверяет индекс массива на корректность. Это значит, что можно выйти за пределы массива и обратиться к памяти,
находящейся дальше последнего элемента массива (или ближе).