Сколько элементов заполнено в массиве C

Question

Если у вас есть массив в C, как вы можете узнать, сколько его заполнено?

Answer 1

Вам необходимо отслеживать это самостоятельно. Нет понятия «полный» (или что-то среднее между ними): вы должны определить это.

Конечно, если элементы смежны в массиве, вы можете использовать элемент NULL, чтобы обозначить «конец» массива, таким образом определяя «полное» состояние в одно и то же время.

Answer 2

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

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

Answer 3

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

Если у вас есть массив указателей на языке C, вы можете увидеть, как это работает на Java. Вы можете использовать нулевые указатели для обозначения «не заполняется, чтобы указать на объект»:

// creates an array of 10 pointers, and initializes all of 
// them to null pointers. If you leave off "{ 0 }", you 
// have to manually initialize them! 
struct foo *array[10] = { 0 }; 

Тогда вы можете просто проверить с

if(array[i] == 0) { 
    printf("Position %d does not point to an object!\n", i); 
} 

Answer 4

Вычтите количество пустых элементов от размера массива , ;-)

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

Answer 5

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

Answer 6

Вы можете сделать цикл while(yourArray != NULL), и через цикл просто увеличивайте целочисленное значение, и это должно вас рассказать.

Answer 7

С точки зрения языка C нет понятия «заполнено». Как только массив определен, ему присваивается память. Для массивов типа array1 (см. Пример ниже) элементы получают инициализацию до 0. Однако для массивов типа array2 элементы могут иметь случайное значение.

Итак, понятие «заполнено» должно быть предоставлено программой. Один из возможных вариантов: «in-band» способ: (a) Выберите одно конкретное значение типа элемента (например, 0xFFFFFFFF) и используйте его для определения свойства fill/empty для каждого элемента массива (однако, поймите, что этот подход отбирает одно другое действительное значение из набора элементов.) и (b) «инициализировать» все элементы массива до этого запрещенного значения в подходящем положении в области программы. (c) Чтобы найти уровень заполнения массива, подсчитайте количество действительных элементов.

$ cat t2.c 
#include <stdio.h> 
#define N 10 

typedef unsigned long int T; 

static const T EmptyElementValue = 0xFFFFFFFF; 
// Choose any suitable value above. However, the chosen value 
// would not be counted as an "empty" element in the array. 

static T array1[ N ]; 

void 
printArray(T a[], size_t length) 
{ 
    size_t i; 
    for(i = 0; i < length; ++i) 
    { 
     printf("%lu, ", a[ i ]); 
    } 
    printf("\n"); 
} 

size_t 
numFilledElements(T a[], size_t length) 
{ 
    size_t fillCount = 0; 
    size_t i; 

    for(i = 0; i < length; ++i) 
    { 
     if(a[ i ] != EmptyElementValue) 
     { 
      fillCount += 1; 
     } 
    } 

    return fillCount; 
} 

int main() 
{ 
    T array2[ N ]; 
    size_t i; 

    printArray(array1, N); 
    printArray(array2, N); 

    //------------------------------------------// 

    // Make array2 empty 
    for(i = 0; i < N; ++i) 
    { 
     array2[ i ] = EmptyElementValue; 
    } 

    // Use some elements in array2 
    array2[ 2 ] = 20; 
    array2[ 3 ] = 30; 
    array2[ 7 ] = 70; 
    array2[ 8 ] = 80; 

    printf("Number of elements \"filled\" in array2 = %u\n", 
     numFilledElements(array2, N )); 

    // Stop using some elements in array2 
    array2[ 3 ] = EmptyElementValue; 

    printf("Number of elements \"filled\" in array2 = %u\n", 
     numFilledElements(array2, N)); 


    return 0; 
} 


$ gcc -Wall t2.c -o t2 


$ ./t2 
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
0, 60225, 2280452, 1627469039, 1628881817, 2281060, 2280680, 1628304199, 1628881818, 47, 
Number of elements "filled" in array2 = 4 
Number of elements "filled" in array2 = 3 

$ 

Answer 8

В C нет встроенного способа узнать, сколько элементов заполнено данными, которые вам интересны. Вам нужно будет построить его самостоятельно. Как уже было сказано, если вы можете иметь значение, которое не будет представлять что-либо (например, 0), вы можете:

1. Подсчитайте элементы, которые не имеют этого неопределенного значения.
2. Если заполненные элементы будут находиться в том же блоке памяти, вы можете посмотреть на неопределенное значение (Страж)

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

Например, если у вас есть массив из 32 элементов или меньше, вам нужно только целое число без знака, чтобы отслеживать ваш массив: 1100010 ...

Ценности:

1 -> Set

2 -> Set

3 -> никакого набора

4 -> не указан

5 -> не установлен

6 -> набор

и т.д.

Итак, всякий раз, когда вы заполняете элемент, вы вызываете функцию, которая устанавливает правильный бит, и когда вы «не заполняете» данные, вы удаляете бит, который ему соответствует.

Как только это будет сделано, все, что вам нужно сделать, это просто вызвать popcount над массивом флагов.