Как найти пустой элемент массива

At first I was thinking,
“They need to use pointer arithmetic so the
object doesn’t get auto de-referenced by the
“[ ]” operator.

Then I realized, no… Arrays in C don’t have
null slots.

I conclude, the asker is:

1. Using an array of structs.

2. Using it as if it were an array of
   pointers to structs.

peoro’s solution is pretty good. But I would recommend modifying it a bit.
Add a “.exists” property to your struct if you want to do it the lazy/simple way.
Simple is not a bad thing, the more parts in a machine the more things that can go wrong.

Code below demonstrates two things:

1. Faking a sparse array using peoro’s solution with .exists flag modification.

2. An actual sparse array using double pointers.

---

#include<stdlib.h> //:for: malloc(...)
#include<stdlib.h> //:for:   free(...)
#include <stdio.h> //:for: printf(...)
int main( void ){
    printf("[BEG:main]n");

    typedef struct MyStruct{
        int whatever;
    } MyStruct;

    int        num = 16; //:sixteen_elements

    //:USE CALLOC HERE! If you use malloc you'll
    //:end up with something even worse than
    //:null pointers... Pointers that point to
    //:random places in memory. 
    //:
    //: It will make your:
    //: if( arr[i] != NULL )... 
    //: look before you leap check worthless.
    MyStruct** arr =(
        calloc(
            1 //:allocating 1 item: arr

            //:Amount of memory taken up by
            //:all 16 MyStruct pointers in array.
        ,   sizeof(MyStruct*)*num
        )
    );;

    //:Initialize only the EVEN slots:
    for(int i = 0; i < num; i+=2 ){
        //:Create new MyStruct in slot i,
        //:initialized with junk data.
        arr[i]= malloc(sizeof(MyStruct));
    };;

    //:If element not null, set it's whatever:
    for(int i = 0; i < num; i++){
        if(NULL != arr[i]){
            arr[i] -> whatever = i;
        };;
    };;

    //:Loop and print to confirm:
    for(int i = 0; i < num; i++){
        if(NULL != arr[i]){
            printf("whatever: %dn", arr[i] -> whatever);
        };;
    };;

    //:ALTERNATIVELY:
    //:If we were going to use peoro's method,
    //:I would advise adding a ".exists" flag
    //:to your struct.

    typedef struct DoublePointersAreTooMuchWork{
        int exists;

        //:Because we are going to use malloc this
        //:time, we have no guarantee what this
        //:value will be. but you will probably
        //:see all of them == 0. If you set
        //: num=1000 you'll probably see a non-zero
        //: entry somewhere. But, no guarantees!
        int mystery_value;
    } MyStruct02;

    MyStruct02* arr2 = malloc(sizeof(MyStruct02)*num);
    for(int i = 0; i < num; i++ ){

        if( i%2 ){ //:evens
            arr2[i].exists = 1;
        }else{
            arr2[i].exists = 0;
        };;
    };;

    for(int i = 0; i < num; i++ ){
        if( arr2[i].exists ){
            printf("Exists:val:%dn", arr2[i].mystery_value);
        }else{
            printf("[Pretend_I_Dont_Exist]n");
        };
    }

    printf("[END:main]n");
} //[[main]____________________________________]//

/** ****************************************** ***
OUTPUT:
[BEG:main]
whatever: 0
whatever: 2
whatever: 4
whatever: 6
whatever: 8
whatever: 10
whatever: 12
whatever: 14
[Pretend_I_Dont_Exist]
Exists:val:0
[Pretend_I_Dont_Exist]
Exists:val:0
[Pretend_I_Dont_Exist]
Exists:val:0
[Pretend_I_Dont_Exist]
Exists:val:0
[Pretend_I_Dont_Exist]
Exists:val:0
[Pretend_I_Dont_Exist]
Exists:val:0
[Pretend_I_Dont_Exist]
Exists:val:0
[Pretend_I_Dont_Exist]
Exists:val:0
[END:main]
*** ****************************************** **/

While I am at it. If you want to run from the command line, name the file:
“NAE.C99”, then create a bash file called “NAE.SH” and put this into it.
Double click the script to run it, or use “./NAE.SH” where it resides in your
git bash terminal.

##################################################
############################# SC[ hkmf-strict ] ##
##################################################
base_name_no_extension="NAE"
##################################################
MY_COMMAND_STRING=$(cat << GCC_COMMAND_01
    gcc                                     
    -x c                                    
    -c $base_name_no_extension.C99          
    -o my_object_file.o                     
    -m64                                    
GCC_COMMAND_01
)                                       
C=$MY_COMMAND_STRING  ############################
C=$C"-Werror        " ## WarningsAreErrors      ##
C=$C"-Wfatal-errors " ## StopAtFirstError       ##
C=$C"-Wpedantic     " ## UseStrictISO_C         ##
C=$C"-Wall          " ## WarnAboutAnyWeirdCode  ##
C=$C"-Wextra        " ## "-Wall" WarningsExtra  ##
C=$C"-std=c99       " ## VersionOf_C_ToUse      ##
MY_COMMAND_STRING=$C  ############################

echo $MY_COMMAND_STRING
     $MY_COMMAND_STRING

C1=" gcc -o EXE.exe my_object_file.o "    
C2=" ./EXE.exe                       "    
C3=" rm my_object_file.o             "    
C4=" rm EXE.exe                      "  
$C1 && echo "OK:"$C1 || "FAIL:$C1"
$C2 && echo "OK:"$C2 || "FAIL:$C2"
$C3 && echo "OK:"$C3 || "FAIL:$C3"
$C4 && echo "OK:"$C4 || "FAIL:$C4"
##################################################
read -p "[END_OF_BUILD_SCRIPT:PressAnyKey]:"
##################################################
############################# SC[ hkmf-strict ] ##
##################################################

This is C99 code by the way. I try to write it avoiding any C99 specific features though.

Все функции для работы с массивами

Разберём самые популярные из них.

Создание массива

Создать пустой массив:

$array = [];

// До версии PHP 5.4 массив создавался так (можно и до сих пор встретить в "старом" коде):
$array = array();

Создать массив с элементами:

$array = ['Audi', 'BMW', 'Honda'];

// В "старом" стиле
$array = array('Audi', 'BMW', 'Honda');

При необходимости можно воспользоваться функцией array_fill($start, $size, $value), которая создаст массив с количеством $size элементов со значением $value, начиная с индекса $start.

$array = array_fill(0, 3, 'Text');
print_r($array);

Результат:

Array
(
  [0] => Text
  [1] => Text
  [2] => Text
)

Можно воспользоваться функцией explode($delimiter, $string), которая из строки $string создаст массив используя разделитель $delimiter, в данном случае запятая.

$string = 'Text1,Text2,Text3';
$array = explode(',', $string);
print_r($array);

Результат:

Array
(
  [0] => Text1
  [1] => Text2
  [2] => Text3
)

Наполнение массива (добавление элементов)

// Создаём пустой массив
$array = [];
// Добавляем элементы в массив
$array[] = 'Audi';
$array[] = 'BMW';
$array[] = 'Honda';

print_r($array);

Можно сразу определить ключ (индекс) для значения массива:

$array = [];
$array[] = 'Audi';
$array[] = 'BMW';
$array[] = 'Honda';
$array[5] = 'Jaguar';
$array['lada'] = 'Lada';
print_r($array);

Результат:

Array
(
  [0] => Audi
  [1] => BMW
  [2] => Honda
  [5] => Jaguar
  [lada] => Lada
)

Функция array_unshift() добавляет один или несколько элементов в начало массива:

$array = ['Audi', 'BMW', 'Honda'];
array_unshift($array, "Lada", "Mazda");
print_r($array);

Результат:

Array
(
  [0] => Lada
  [1] => Mazda
  [2] => Audi
  [3] => BMW
  [4] => Honda
)

Функция array_push() добавляет один или несколько элементов в конец массива:

$array = ['Audi', 'BMW', 'Honda'];
array_push($array, "Lada", "Mazda");
print_r($array);

Результат:

Array
(
  [0] => Audi
  [1] => BMW
  [2] => Honda
  [3] => Lada
  [4] => Mazda
)

Узнать количество элементов в массиве (Размер массива)

Узнать количество элементов массива (размер массива) можно следующими способами:

// Функция count()
$array = ['Audi', 'BMW', 'Honda'];
$count = count($array);
print_r($count); // 3

// Функция sizeof()
$array = ['Audi', 'BMW', 'Honda'];
$size = sizeof($array);
print_r($size); // 3

Если в функцию count() вторым параметром передать встроенную в PHP константу COUNT_RECURSIVE, то мы получим количество элементов массива и всех подмассивов, которые в нём находятся:

$cars = [
  'Russian Federation' => [
    'Lada',
    'ГАЗ',
  ],
  'Germany' => [
    'Mercedes Benz',
    'Audi',
    'BMW',
    'Porsche',
    'Opel',
  ]
];

$count = count($cars, COUNT_RECURSIVE);
print_r($count); // 9

Работа с ключами массива

Проверить существование ключа (индекса):

$array = [
  'key_1' => 'Value 1',
  'key_2' => 'Value 2',
  'key_3' => 'Value 3',
];

if (array_key_exists('key_2', $array)) echo 'Ключ существует';
else echo 'Ключ не найден!';

Получить элемент массива по его ключу (индексу):

$array = ['Audi', 'BMW', 'Honda'];
// Получить первый элемент
$elem = $array[0]; 
print_r($elem); // Audi

Функция array_keys() возвращает числовые и строковые ключи, содержащиеся в массиве:

$array = ['Audi', 'BMW', 'Honda'];
$keys = array_keys($array);
print_r($keys);

Результат:

Array
(
  [0] => 0
  [1] => 1
  [2] => 2
)

Пример с ассоциативным массивом:

$cars = [
  'Russian Federation' => [
    'Lada',
    'ГАЗ',
  ],
  'Germany' => [
    'Mercedes Benz',
    'Audi',
    'BMW',
    'Porsche',
    'Opel',
  ]
];
$keys = array_keys($cars);
print_r($keys);

Результат:

Array
(
  [0] => Russian Federation
  [1] => Germany
)

Функция array_key_first() получает первый ключ массива:

$array = ['Audi', 'BMW', 'Honda'];
$elem = array_key_first($array);
print_r($elem); // 0

Функция array_key_last() получает последний ключ массива:

$array = ['Audi', 'BMW', 'Honda'];
$elem = array_key_last($array);
print_r($elem); // 2

Функция array_search() осуществляет поиск данного значения в массиве и возвращает ключ первого найденного элемента в случае успешного выполнения:

$array = ['Audi', 'BMW', 'Honda'];
$elem = array_search('BMW', $array);
print_r($elem); // 1

Получение элементов массива

Получить элемент массива по его ключу (индексу):

$array = ['Audi', 'BMW', 'Honda'];
// Получить первый элемент
$elem = $array[0]; 
print_r($elem); // Audi

Ассоциативный массив:

$cars = [
  'Russian Federation' => [
    'Lada',
    'ГАЗ',
  ],
  'Germany' => [
    'Mercedes Benz',
    'Audi',
    'BMW',
    'Porsche',
    'Opel',
  ]
];
$elem = $cars['Germany'];
print_r($elem);

Результат:

Array
(
  [0] => Mercedes Benz
  [1] => Audi
  [2] => BMW
  [3] => Porsche
  [4] => Opel
)

Получить первый элемент массива (функция current()):

$array = ['Audi', 'BMW', 'Honda'];
$elem = current($array);
print_r($elem); // Audi

Получить последний элемент массива (функция end()):

$array = ['Audi', 'BMW', 'Honda'];
$elem = end($array);
print_r($elem); // Honda

Получить часть (срез) массива. Функция array_slice($array, $offset, $length) возвращает часть массива начиная с индекса $offset длиной $length. Если $offset отрицательный, то отчет начинается с конца массива. $length можно не указывать, тогда функция вернет все элементы до конца массива начиная с индекса $offset:

$array = ['Audi', 'BMW', 'Honda'];
$elements = array_slice($array, 0, 2);
print_r($elements);

Результат:

Array
(
  [0] => Audi
  [1] => BMW
)

Функция array_shift() извлекает первый элемент из массива и возвращает его значение.

$array = ['Audi', 'BMW', 'Honda'];
$first = array_shift($array);
print_r($first); // Audi

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

$array = ['Audi', 'BMW', 'Honda'];
$first = array_shift($array);
print_r($array);

Результат:

Array
(
  [0] => BMW
  [1] => Honda
)

Функция array_pop() извлекает последний элемент из массива и возвращает его значение.

$array = ['Audi', 'BMW', 'Honda'];
$last = array_pop($array);
print_r($last); // Honda

Чтобы извлечь из массива часть, можно применить функции array_slice() и array_diff().

$array = ['Audi', 'BMW', 'Honda'];
$slice = array_slice($array, 0, 2);
$diff = array_diff($array, $slice);

print_r($slice);
print_r($diff);

Результат:

Array
(
  [0] => Audi
  [1] => BMW
)
Array
(
  [2] => Honda
)

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

$array = ['Audi', 'BMW', 'Honda'];
$values = array_values($array);
print_r($values);

Результат:

Array
(
  [0] => Audi
  [1] => BMW
  [2] => Honda
)

Выбрать все ключи массива можно с помощью функции array_keys(). Создаётся новый массив состоящий из ключей исходного массива:

$array = ['Audi', 'BMW', 'Honda'];
$keys = array_keys($array);
print_r($keys);

Результат:

Array
(
  [0] => 0
  [1] => 1
  [2] => 2
)

Выбрать все случайные ключи из массива можно с помощью функции array_rand($array, $count). Если $count больше единицы, то результат будет в виде массива:

$array = ['Audi', 'BMW', 'Honda'];
$rand = array_rand($array);
$rand_2 = array_rand($array, 2);

print_r($rand);
print_r($rand_2);

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

Проверить, есть ли значение в массиве:

$array = ['Audi', 'BMW', 'Honda'];

if (in_array('BMW', $array)) {
  echo 'Найдено значение "BMW"';
}

// или
if (array_search('BMW', $array) !== false) {
  echo 'Найдено значение "BMW"';
}

Проверить, есть ли ключ в массиве:

$array = ['Audi', 'BMW', 'Honda'];

if (array_key_exists(2, $array)) {
  echo 'Найден ключ 2';
}

// или
if (isset($array[2])) {
  echo 'Найден ключ 2';
}

Удаление элементов из массива

Функция unset() удаляет переменные и элементы массива:

$array = ['Audi', 'BMW', 'Honda'];

// Удаление по ключу
unset($array[1]);

print_r($array);

Результат:

Array
(
  [0] => Audi
  [2] => Honda
)

Можно удалить элемент массива по значению:

$array = ['Audi', 'BMW', 'Honda'];

// Удаление по значению
unset($array[array_search('BMW', $array)]);

print_r($array);

Результат:

Array
(
  [0] => Audi
  [2] => Honda
)

Для удаления пустых значений в массиве в PHP нет отдельной функции, поэтому применяют функцию array_diff(), которая возвращает расхождения массивов:

$array = ['Audi', '', 'Honda'];
$array = array_diff($array, ['']);
print_r($array);

Результат:

Array
(
  [0] => Audi
  [2] => Honda
)

Удалить повторяющиеся значения массива:

$array = ['Audi', 'BMW', 'Audi', 'Honda'];
$array = array_unique($array);
print_r($array);

Результат:

Array
(
  [0] => Audi
  [1] => BMW
  [3] => Honda
)

Объединение массивов

$array_1 = ['Audi', 'BMW', 'Honda'];
$array_2 = ['Lexus', 'Nissan'];
$result = array_merge($array_1, $array_2);
print_r($result);

Результат:

Array
(
  [0] => Audi
  [1] => BMW
  [2] => Honda
  [3] => Lexus
  [4] => Nissan
)

Разделить массив на части

Функция array_chunk($array, $size) создает новый многомерный массив из исходного, деля его на равные части:

$array = ['Audi', 'BMW', 'Honda', 'Lexus', 'Nissan', 'Mazda', 'Opel', 'Subaru'];
$result = array_chunk($array, 3);
print_r($result);

Результат:

Array
(
  [0] => Array
  (
    [0] => Audi
    [1] => BMW
    [2] => Honda
  )
  [1] => Array
  (
    [0] => Lexus
    [1] => Nissan
    [2] => Mazda
  )
  [2] => Array
  (
    [0] => Opel
    [1] => Subaru
  )
)

Если требуется разделить массив на определенное количество частей можно воспользоваться следующим приемом:

$array = ['Audi', 'BMW', 'Honda', 'Lexus', 'Nissan', 'Mazda', 'Opel', 'Subaru'];
$result = array_chunk($array, ceil(count($array) / 2));
print_r($result);

Результат:

Array
(
	[0] => Array
  (
    [0] => Audi
    [1] => BMW
    [2] => Honda
    [3] => Lexus
  )

	[1] => Array
  (
    [0] => Nissan
    [1] => Mazda
    [2] => Opel
    [3] => Subaru
  )
)

Группировка массивов по ключу

Дано: Есть многомерный массив из товаров с типами цен:

$array = [
  0 => [
    'supplierId' => '1490000210',
    'vat_mrc' => 20839.2,
  ],
  1 => [
    'supplierId' => '1490000210',
    'tarif' => 18280,
  ],
  2 => [
    'supplierId' => '1490000210',
    'vat_tarif' => 21936,
  ],
  3 => [
    'supplierId' => '1079000450',
    'vat_mrc' => 19328.06,
  ],
  4 => [
    'supplierId' => '1079000450',
    'tarif' => 21765.83,
  ],
  5 => [
    'supplierId' => '1079000450',
    'mrc' => 10300.30,
  ],
];

Задача: Сгруппировать товары по коду поставщика. То есть, из пяти представленных массивов должно получиться два со всеми типами цен:

$result = [];
foreach ($array as $item):
  foreach ($item as $key => $value):
    $result[$item['supplierId']][$key] = $value;
  endforeach;
endforeach;

Результат:

Array
(
[1490000210] => Array
  (
    [supplierId] => 1490000210
    [vat_mrc] => 20839.2
    [tarif] => 18280
    [vat_tarif] => 21936
  )
[1079000450] => Array
  (
    [supplierId] => 1079000450
    [vat_mrc] => 19328.06
    [tarif] => 21765.83
    [mrc] => 10300.3
  )
)