Стандартные алгоритмы и массивы C++

Источник: CppBuilder

Michel Leunen

Вы никогда не думали о том, что было бы просто замечательно, если бы вы могли использовать стандартные алгоритмы с массивами языка C++? Да, это можно сделать! Стандартные алгоритмы разработаны для того, чтобы использовать стандартные контейнеры и итераторы, но контейнеры представляют собой ничто иное, как некую разновидность "умных" массивов, а итераторы - ничто иное, как указатели.

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

void sort (RandomAccessIterator first, RandomAccessIterator last);

И у вас может возникнуть искушение использовать его как-то в этом роде:

int array[10];
std::sort(&array[0], &array[10]);

Проблема в том, что использование &array[10] приводит к неопределенному поведению, так как элемент array[10] уже лежит за границами массива. Но использование арифметики указателей вполне допустимо. Вы можете обратиться к указателю, который адресует конечный элемент массива. Такой код будет верным:

int array[10];
std::sort(array, array+10);

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

#include <iostream>
#include <algorithm>

// простая глобальная функция для использования
// с алгоритмом for_each
void Power(int value)
{
  std::cout << value*value << ",";
}

int main()
{
  int array[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
  
  for(int i = 0; i < 10; ++i)
    std::cout << array[i] << ",";
  std::cout << std::endl;
  
  // перемешиваем элементы в массиве
  std::cout << "randomize" << std::endl;
  std::random_shuffle(array, array + 10);
  for(int i = 0; i < 10;++i)
    std::cout << array[i] << ",";
  std::cout << std::endl;
  
  // find возвращает итератор (в данном случае - указатель)
  // на элемент, если элемент найден и end(),
  // (последний элемент массива), если элемент не найден
  std::cout << "find" << std::endl;
  int* ptr = std::find(array, array + 10, 4);
  if(ptr == array + 10)
    std::cout << "not found" << std::endl;
  else
    std::cout << *ptr << " found" << std::endl;
  
  // меняем порядок элементов в массиве
  std::cout << "reverse" << std::endl;
  std::reverse(array, array + 10);
  for(int i = 0; i < 10; ++i)
    std::cout << array[i] <<",";
  std::cout << std::endl;
  
  // сортировка
  std::cout << "sort" << std::endl;
  std::sort(array, array + 10);
  for(int i = 0; i < 10; ++i)
    std::cout << array[i] <<",";
  std::cout << std::endl;
  
  // создаем копию массива
  std::cout << "copy" << std::endl;
  int another_array[10];
  std::copy(array, array + 10, another_array);
  for(int i = 0; i < 10; ++i)
    std::cout << array[i] <<",";
  std::cout << std::endl;
  for(int i = 0; i < 10; ++i)
    std::cout<< another_array[i] <<",";
  std::cout << std::endl;
  
  // std::equal возвращает true,
  // если массивы абсолютно идентичны
  std::cout << "equality" << std::endl;
  if(std::equal(array, array + 10, another_array))
    std::cout << "the 2 arrays are equal" << std::endl;
  
  // std::fill заполняет массив указанным значением
  std::cout << "fill" << std::endl;
  std::fill(array, array + 10, 22);
  for(int i = 0; i < 10; ++i)
    std::cout << array[i] << ",";
  std::cout << std::endl;
  
  // std::swap меняет элементы массива местами
  std::cout << "swap" <<std::endl;
  std::swap_ranges(array, array + 10, another_array);
  for(int i = 0; i < 10; ++i)
    std::cout << array[i] <<",";
  std::cout << std::endl;
  for(int i = 0; i < 10; ++i)
    std::cout << another_array[i] << ",";
  std::cout << std::endl;
  
  // std::count возвращает количество вхождений
  // элемента в массив 
  std::cout << "count" << std::endl;
  int count = std::count(another_array,
    another_array + 10, 22);
  std::cout << "there is "
            << count
            << " elements in new_array with value 22"
            << std::endl;
  
  std::cout << "for_each" << std::endl;
  std::for_each(array, array + 10, Power);
  
  return 0;
}

Вышеприведенный пример использует простой массив целых числе. Ну а как обстоят дела с массивами определенных пользователем типов?

Стандартные алгоритмы используют операторы '<', '==' и пр для сравнения двух элементов массива. Таким образом, вам необходимо определить операторы для ваших собственных типов. Ниже я создал структуру, содержащую два строковых (char) массива и определил оператор '<' для использования совместно с std::sort.

#include <iostream.h>
#include <algorithm>

struct MasterOfCpp
{
  char FirstName[16];
  char LastName[16];
};

bool operator < (const MasterOfCpp& lhs, const MasterOfCpp& rhs)
{
  return (strcmp(lhs.LastName, rhs.LastName) < 0)
      // ((strcmp(lhs.LastName, rhs.LastName) == 0)
          && (strcmp(lhs.FirstName, rhs.FirstName) < 0));
}

int main()
{
  MasterOfCpp moc[6];
  strcpy(moc[0].LastName,"Stroustrup");
  strcpy(moc[0].FirstName,"Bjarne");
  strcpy(moc[1].LastName,"Austern");
  strcpy(moc[1].FirstName,"Matt");
  strcpy(moc[2].LastName,"Meyers");
  strcpy(moc[2].FirstName,"Scott");
  strcpy(moc[3].LastName,"Josuttis");
  strcpy(moc[3].FirstName,"Nicolai");
  strcpy(moc[4].LastName,"Sutter");
  strcpy(moc[4].FirstName,"Herb");
  strcpy(moc[5].LastName,"Alexandrescu");
  strcpy(moc[5].FirstName,"Andrei");

  std::cout<< "array not sorted :" << std::endl;
  for (int i =0; i < 6; ++i)
      std::cout << moc[i].LastName
                << " " < <moc[i].FirstName
                << std::endl;
               
  std::cout << std::endl;
  
  std::cout << "array sorted :" << std::endl;
  std::sort(moc,moc+6);
  for (int i = 0; i < 6; ++i)
      std::cout << moc[i].LastName
                << " "<< moc[i].FirstName
                << std::endl;
  
  return 0;
}

Стандартные алгоритмы и массивы C++ (исходники)