Определить длину массива
но данная конструкция как-то коряво работает, если массив передавать в функцию, и в гугле нашел, что так работать не будет с массивами которые передаются как параметры функциям
кто знаком с паскалем, там есть функция узнать длину массива обычных стандартных типов это
нужно что-то подобное мне и в с++
Как такое чудо можно организовать?
Кстати все примеры которые видел, с передачей, там передается не только сам массив, но еще и его размер вторым параметром.
Может в этом кроется какой-то своеобразный смысл? Но как по привычке паскалевской, думаю так же узнать размер, нужно для цикла считающего до конца массива.
Определить среднюю длину непрерывных участков отрицательных значений элементов массива
в массиве A определить среднюю длину непрерывных участков отрицательных значений элементов буду.
Определить длину и позицию слова, которое имеет наименьшую длину в строке
Определить длину и позицию слова, которое имеет наименьшую длину в строке. Строки Пожалуйста.
Определить длину самой упорядоченной части массива
Проверить упорядочен ли массив b(n) по возрастанию или убыванию элементов. Если массив не.
Определить длину вектора, сформированного из элементов массива
Еще одна проблема помогите пожалуйста.. Масив: Z = <−2; 9; 10; −2; 9; 1; 14; 9;.
ммм, я имел ввиду про стандартные методы, даже не стандартные, а простые, просто не от меня зависит то, что и как я бы это использовал, имеются ограничения при решении задач 
Но все равно спасибо 
что значит «длину массива»?
длинна массива по количеству элементов определяется при объявлении. Вектора, как в примере выше, если ты не знаешь сколько у тебя будет элементов, тогда через вектор.
А если тебе надо узнать, сколько байт занимает массив, то
далее использую функцию
Добавлено через 2 минуты
Arcor, а вообще для подсчета суммы есть std::accumulate
заранее спасибо, и спасибо всем, пытавшимся мне помочь
Изучаем C++. Часть 7. Массивы и работа с ними
Разбираемся, как пользоваться одним из самых удобных способов хранения данных.
Это седьмая часть из серии статей «Глубокое погружение в C++». В прошлой статье мы узнали, как использовать циклы while, do-while и for и сокращать с их помощью код. Сегодняшняя тема — массивы.
Массив — это определённое число ячеек памяти, расположенных подряд. Они позволяют эффективно хранить однотипные данные: зарплаты сотрудников, координаты персонажей, баллы учеников и так далее.
На картинке выше показано объявление массива из четырёх элементов целочисленного типа. Несмотря на то что значения элементам не присваивались, массив всё равно будет занимать такой объём памяти, который занимали бы четыре переменные. В данном случае — 16 байт.
Массивы очень удобные и быстрые: расположение ячеек друг за другом позволяет увеличить скорость работы с данными в них.
Пишет о программировании, в свободное время создает игры. Мечтает открыть свою студию и выпускать ламповые RPG.
Как объявить массив в C++
Есть несколько способов объявления массивов:
Нумерация в массивах начинается с нуля, а не с единицы. При этом длина остается обычной. То есть в массиве длиной в десять ячеек индекс последней будет 9.
Важно! Массивы — иммутабельные (неизменяемые). Вы можете скорректировать значения отдельных элементов, но не сам массив — нельзя изменить его длину или присвоить одному массиву другой.
Всегда следите, чтобы не обращаться к ячейке данных, которая находится за пределами массива. Если длина равна 5, а вы обратитесь к ячейке под индексом 5, 6, 7 и так далее, то результат может быть непредсказуемым.
Как определить размер моего массива в C?
Как определить размер моего массива в C?
То есть, количество элементов, которые может содержать массив?
ОТВЕТЫ
Ответ 1
Управляющее резюме:
Полный ответ:
Чтобы определить размер вашего массива в байтах, вы можете использовать оператор sizeof :
На моем компьютере длина целых 4 байта, поэтому n равно 68.
Чтобы определить количество элементов в массиве, мы можем разделить общий размер массива на размер элемента массива. Вы можете сделать это с типом, как это:
Еще одним преимуществом является то, что теперь вы можете легко параметризовать имя массива в макросе и получить:
Ответ 2
Выход (в 64-разрядной ОС Linux):
Выход (в 32-разрядной ОС Windows):
Ответ 3
Стоит отметить, что sizeof не помогает при работе со значением массива, которое разложилось на указатель: хотя он указывает на начало массива, компилятору он совпадает с указателем на один элемент этого массива. Указатель не «помнит» ничего о массиве, который использовался для его инициализации.
Ответ 4
Итак: Если у вас есть следующее:
Вы можете найти количество элементов с таким кодом:
Это, для меня, намного легче, чем альтернатива с круглыми скобками. Я также предпочитаю использовать звездочку в правой части деления, поскольку она более лаконична, чем индексирование.
Конечно, это тоже время компиляции, поэтому нет необходимости беспокоиться о делении, влияющем на производительность программы. Поэтому используйте эту форму, где можете.
Всегда лучше использовать sizeof для фактического объекта, если он есть, а не на типе, поскольку вам не нужно беспокоиться о том, чтобы сделать ошибку и указать неправильный тип.
Например, скажем, у вас есть функция, которая выводит некоторые данные в виде потока байтов, например, по сети. Позвольте вызвать функцию send() и заставить в качестве аргументов указывать указатель на отправляемый объект и количество байтов в объекте. Итак, прототип будет выглядеть следующим образом:
И тогда вам нужно отправить целое число, поэтому вы выполните его следующим образом:
Теперь вы защищены. Конечно, вы дублируете имя переменной, но это имеет высокую вероятность взлома способом, который может обнаружить компилятор, если вы его измените.
Ответ 5
Откроется эта ссылка для объяснения
Ответ 6
Вы можете использовать оператор sizeof, но он не будет работать для функций, потому что для ссылки на указатель вы можете сделать следующее, чтобы найти длину массива:
Ответ 7
Если вам известен тип данных массива, вы можете использовать что-то вроде:
Или, если вы не знаете тип данных массива, вы можете использовать что-то вроде:
Примечание. Эта вещь работает только в том случае, если массив не определен во время выполнения (например, malloc), и массив не передается в функции. В обоих случаях arr (имя массива) является указателем.
Ответ 8
Фактически оценивается как:
Он правильно оценивает:
Это действительно не имеет особого отношения к размеру массивов явно. Я только что заметил много ошибок, не наблюдая, как работает препроцессор C. Вы всегда переносите параметр макроса, а не включаете в него выражение.
Это правильно; мой пример был плохим. Но это на самом деле то, что должно произойти. Как уже упоминалось ранее, p + 1 закончится как тип указателя и аннулирует весь макрос (как если бы вы попытались использовать макрос в функции с параметром указателя).
В конце дня, в данном конкретном случае, ошибка не имеет большого значения (поэтому я просто теряю время, huzzah!), потому что у вас нет выражений с типом «массива», Но на самом деле вопрос о тонкостях оценки препроцессора, я думаю, является важным.
Ответ 9
Для многомерных массивов это несколько сложнее. Часто люди определяют явные макроконстанты, т.е.
Но эти константы могут быть вычислены и во время компиляции с sizeof:
Обратите внимание, что этот код работает в C и С++. Для массивов с более чем двумя измерениями используйте
Ответ 10
Размер массива в C:
Ответ 11
Ответ 12
C ‘native’ массивы не сохраняют свой размер. Поэтому рекомендуется сохранять длину массива в отдельной переменной /const и передавать его всякий раз, когда вы передаете массив, а именно:
Вы ДОЛЖНЫ всегда избегать встроенных массивов (если только вы не можете, и в этом случае, обратите внимание на вашу ногу). Если вы пишете С++, используйте контейнер STL. «По сравнению с массивами они обеспечивают почти ту же производительность», и они гораздо полезнее!
Ответ 13
Ответ 14
@Магнус: стандарт определяет sizeof как уступающий количеству байтов в объекте, а sizeof (char) всегда один. Количество бит в байте является специфичным для реализации.
Изменить: стандартный раздел ANSI С++. 5.3.3. Размер:
Оператор sizeof дает количество байтов в представлении объекта своего операнда. [. ] sizeof (char), sizeof (подпись char) и sizeof (без знака char) равны 1; результат sizeof, применяемый к любому другому фундаментальному типу, определяется реализацией.
Раздел 1.6 Модель памяти С++:
Основным блоком памяти в модели памяти С++ является байт. Байт, по меньшей мере, достаточно большой, чтобы содержать любой элемент базового набора символов выполнения и состоит из непрерывной последовательности бит, число которых определяется реализацией.
Ответ 15
Википедия ошибается, Skizz прав. sizeof (char) равен 1, по определению.
Я имею в виду, просто внимательно прочитайте запись в Википедии, чтобы понять, что это неправильно. msgstr «кратные char». sizeof(char) никогда не может быть ничего, кроме «1». Если бы это было, скажем, 2, это означало бы, что sizeof(char) был в два раза меньше char!
Ответ 16
Я включил для вас какой-то код. Это не очень полезно, но вы можете расширить его с большим количеством функций. Если честно, если это то, что вы хотите, вы должны прекратить использовать C и использовать другой язык с этими встроенными функциями.
Ответ 17
Лучший способ сохранить эту информацию, например, в структуре:
Внедрите все необходимые функции, такие как создание, уничтожение, проверка равенства и все остальное, что вам нужно. Это легче передать в качестве параметра.
Ответ 18
Ответ 19
Ответ 20
Для более подробной информации смотрите здесь, а также здесь.
Как мне узнать длину массива?
Есть ли способ узнать, сколько значений имеет массив? Также сработает определение того, дошел ли я до конца массива.
27 ответов
Если вы имеете в виду массив в стиле C, вы можете сделать что-то вроде:
Это не работает с указателями (т.е. не будет работать ни в одном из следующих случаев):
Вы также можете рассмотреть возможность использования std::array из C ++ 11, который предоставляет его длину без дополнительных затрат на собственный массив C.
Выполнение sizeof myArray даст вам общее количество байтов, выделенных для этого массива. Затем вы можете узнать количество элементов в массиве, разделив его на размер одного элемента в массиве: sizeof myArray[0]
Итак, вы получите что-то вроде:
Есть ли способ узнать, сколько значений имеет массив?
Также сработает определение того, дошел ли я до конца массива.
Я не вижу для этого способа, если ваш массив не является массивом символов (например, строкой).
(Да, это насмешливый ответ)
Если T является типом массива, предоставляет значение константы члена, равное количеству измерений массива. Для любого другого типа значение равно 0.
BTY, чтобы получить общее количество элементов в многомерном массиве:
Или поместите его в шаблон функции:
Больше примеров того, как их использовать, можно найти, перейдя по ссылкам.
Также существует способ TR1 / C ++ 11 / C ++ 17 (см. Его Live на Coliru ):
Это довольно старый и легендарный вопрос, и на него уже есть много удивительных ответов. Но со временем к языкам добавляются новые функции, поэтому нам нужно постоянно обновлять вещи в соответствии с новыми доступными функциями.
Я только заметил, что никто еще не упомянул о C ++ 20. Вот и подумал написать ответ.
C ++ 20
C ++ 17
Старый
Этот традиционный подход уже упоминается во многих других ответах.
В C ++ массив не передается по значению, вместо этого передается указатель на массив. Поскольку в некоторых случаях передача целых массивов может быть дорогостоящей операцией. Вы можете проверить это, передав массив какой-либо функции и внося некоторые изменения в массив, а затем снова распечатав массив в main. Вы получите обновленные результаты.
И, как вы уже знаете, функция sizeof() дает количество байтов, поэтому в другой функции она вернет количество байтов, выделенных для указателя, а не для всего массива. Так что этот подход не работает.
Но я уверен, что вы можете найти хороший способ сделать это в соответствии с вашими требованиями.
Вместо использования встроенной функции массива, известной как:
Вы должны использовать класс массива и шаблон массива. Пытаться:
Итак, теперь, если вы хотите найти длину массива, все, что вам нужно сделать, это использовать функцию размера в классе массива.
И это должно вернуть длину элементов в массиве.
В C ++, используя класс std :: array для объявления массива, можно легко найти размер массива, а также последний элемент.
Фактически, класс массива имеет множество других функций, которые позволяют нам использовать массив в качестве стандартного контейнера.
Ссылка 1 на класс C ++ std :: array
Ссылка 2 на класс std :: array
Примеры в ссылках полезны.
У вас есть несколько вариантов, которые можно использовать для получения размера массива C.
int myArray [] = <0, 1, 2, 3, 4, 5, 7>;
sizeof(array_name) дает размер всего массива, а sizeof(int) дает размер типа данных каждого элемента массива.
Таким образом, деление размера всего массива на размер одного элемента массива дает длину массива.
Вот одна реализация ArraySize из Google Protobuf.
ARRAYSIZE (arr) работает, проверяя sizeof (arr) (количество байтов в массиве) и sizeof (* (arr)) (количество байтов в одном элементе массива). Если первое делится на второе, возможно, arr действительно является массивом, и в этом случае результатом деления будет # элементов в массиве. В противном случае arr не может быть массивом, и мы генерируем ошибку компилятора, чтобы предотвратить компиляцию кода.
Поскольку размер bool определяется реализацией, нам нужно преобразовать! (Sizeof (a) & sizeof (* (a))) в size_t, чтобы гарантировать, что конечный результат имеет тип size_t.
Этот макрос не идеален, поскольку он ошибочно принимает определенные указатели, а именно, когда размер указателя делится на размер указателя. Поскольку весь наш код должен пройти через 32-битный компилятор, где указатель составляет 4 байта, это означает, что все указатели на тип, размер которого равен 3 или больше 4, будут (справедливо) отклонены.
Исходный код:
Просто подумал, но просто решил создать переменную счетчика и сохранить размер массива в позиции [0]. Я удалил большую часть кода, который был у меня в функции, но после выхода из цикла вы увидите, что prime [0] присваивается окончательное значение «a». Я пробовал использовать векторы, но VS Express 2013 мне это не очень понравилось. Также обратите внимание, что ‘a’ начинается с единицы, чтобы избежать перезаписи [0], и инициализируется в начале, чтобы избежать ошибок. Я не эксперт, просто подумал, что поделюсь.
Хорошее решение, использующее дженерики:
Просто вы можете использовать этот фрагмент:
Для старого компилятора g ++ вы можете сделать это
Вы можете найти длину массива следующим образом:
Избегайте использования типа вместе с sizeof, так как sizeof(array)/sizeof(char) внезапно испортится, если вы измените тип массива.
Я предлагаю здесь хитрое решение:
Вы всегда можете сохранить length в первом элементе:
Одна из наиболее распространенных причин, по которой вы в конечном итоге будете это искать, заключается в том, что вы хотите передать массив в функцию и не должны передавать другой аргумент для его размера. Вы также хотели бы, чтобы размер массива был динамическим. Этот массив может содержать объекты, а не примитивы, а объекты могут быть сложными, так что size_of () не является безопасным вариантом для вычисления количества.
Как предлагали другие, рассмотрите возможность использования std :: vector или list и т.д. вместо примитивного массива. Однако на старых компиляторах у вас все равно не будет окончательного решения, которое вы, вероятно, захотите, просто сделав это, потому что для заполнения контейнера требуется кучка уродливых строк push_back (). Если вы похожи на меня, вам нужно однострочное решение с задействованными анонимными объектами.
Если вы выберете альтернативу контейнеру STL примитивному массиву, этот пост SO может быть вам полезен для способов его инициализации: Каков самый простой способ инициализировать std :: vector с жестко запрограммированными элементами?
Вот метод, который я использую для этого, который будет универсально работать на всех компиляторах и платформах:
Создайте структуру или класс как контейнер для вашей коллекции объектов. Определите функцию перегрузки оператора для 0
Я лично предлагаю (если вы не можете работать со специализированными функциями по какой-либо причине) сначала расширить совместимость типов массивов с тем, как вы обычно их использовали (если бы вы хранили значения ≥ 0:
Допустим, у вас есть глобальный массив, объявленный вверху страницы.
Чтобы узнать, сколько элементов (в C ++) в массиве, введите следующий код:
Sizeof (NAME_OF_ARRAY) / 4 вернет вам количество элементов для данного имени массива.
Обратите внимание, что вам не нужно знать, какой тип данных представляет собой массив, даже если это пользовательский тип данных.
Есть ли способ определить размер массива C++ программно? А если нет, то почему?
этот вопрос был вдохновлен аналогичным вопросом: Как удалить[] «знать» размер массива операндов?
мой вопрос немного иначе: есть ли способ определить размер массива c++ программно? А если нет, то почему? каждая функция, которую я видел, которая принимает массив, также требует целочисленного параметра, чтобы дать ему размер. Но, как указал связанный вопрос, delete[] должен знать размер памяти, чтобы быть освободившему.
рассмотрим этот код C++:
это выводит » Size of arr: 4 «, который является просто размером указателя. Было бы неплохо иметь некоторую функцию, которая печатает 256, но я не думаю, что она существует в C++. (Опять же, часть вопроса заключается в том, почему он не существует.)
уточнение: Я знаю, что если я объявил массив на стеке вместо кучи (т. е. » int arr[256]; «), что sizeof оператор вернет 1024 (длина массива * sizeof (int)).
20 ответов:
delete [] Не знаю размер, который был выделен. Однако эти знания хранятся в среде выполнения или в диспетчере памяти операционной системы, что означает, что они недоступны компилятору во время компиляции. И sizeof() не является реальной функцией, она фактически оценивается в константу компилятором, что он не может сделать для динамически выделенных массивов, размер которых не известен во время компиляции.
кроме того, рассмотрим это пример:
одной из причин этого является то, что C и C++ оставляют управление памятью программисту и операционной системе, поэтому у них также нет сборки мусора. Реализация new и delete не является частью стандарта C++, потому что C++ предназначен для использования на различных платформах, которые могут управлять своей памятью очень по-разному. Возможно, можно позволить C++ отслеживать все выделенные массивы и их размеры, если вы пишете текстовый процессор для окна windows, работающего на последнем процессоре Intel, но это может быть совершенно невозможно, когда вы пишете встроенную систему, работающую на DSP.
нет, это невозможно сделать в стандартном C++.
именно поэтому комитет по стандартам добавил std: vector, который отслеживает его точный размер.
Ну есть на самом деле способ определить размер, но это не «безопасно» и будет отличаться от компилятора к компилятору. поэтому он не должен использоваться вообще.
когда вы делаете: int* arr = new int[256];
так, чтобы дать вам количество «элементов»
printf («количество элементов %d», *p_iToSize / sizeof(int));
для каждого malloc, new, независимо от того, что перед блоком памяти continuos, который вы получаете, также выделяется место, зарезервированное с некоторой информацией о блоке памяти, который вам был предоставлен.
общий способ справиться с этим-либо использовать вектор