Create a library that contains all of the array tool functions that you have created. You will create both a header file and a source file, although the implementation will be slightly different depending on whether you are using a fixed type or a templated type.

Integer implementation

The header file int_array_tools.h will contain all of the function declarations.

A library that does not use templates may be also appropriate for older C compilers, so we will use the older include guard (shown in red) to prevent the header file from being loaded twice.

// int_array_tools.h
#ifndef INT_ARRAY_TOOLS_H
#define INT_ARRAY_TOOLS_H

bool all_zero( int array[], std::size_t capacity );
bool all_non_zero( int array[], std::size_t capacity );
bool has_zero( int array[], std::size_t capacity );
bool has_non_zero( int array[], std::size_t capacity );
void  left_shift( int array[], std::size_t capacity, std::size_t n );
void right_shift( int array[], std::size_t capacity, std::size_t n );
void  left_circular_shift( int array[], std::size_t capacity, std::size_t n );
void right_circular_shift( int array[], std::size_t capacity, std::size_t n );
void fill( int array[], std::size_t capacity, int value = 0 );
int *shrink( int *array, std::size_t capacity );
int *resize( int *array, std::size_t capacity, std:size_t new_capacity );
int *interleave( int array_1[], std::size_t capacity_1,
                 int array_2[], std::size_t capacity_2 );
std::size_t      find( int array[], std::size_t capacity, int sought_value );
std::size_t *find_all( int array[], std::size_t capacity, int sought_value );
void partial_sums( int array[], std::size_t capacity );
int *concatenate( int array_1[], std::size_t capacity_1,
                  int array_2[], std::size_t capacity_2 );
void reverse( int array[], std::size_t capacity );
void permute( int array[], std::size_t *permutation_array, std::size_t capacity );

void print( int array[], std::size_t capacity,
                         std::size_t max_leading = 0,
                         std::size_t max_trailing = 0,
                         char *opening_delimiter = "{",
                         char *closing_delimiter = "}",
                         char *separator = "," );

void print( int array[], std::size_t capacity,
                         std::size_t max_leading = 0,
                         std::size_t max_trailing = 0,
                         std::string opening_delimiter = "{",
                         std::string closing_delimiter = "}",
                         std::string separator = "," );

#endif

All the function definitions would be contained in the corresponding file int_array_tools.cpp and that file would have include the pre-processor directive at the top:

#include "int_array_tools.h";

Templated implementation

The templated library will ensure that this source code is only ever included once using the pragmatic directivie #pragma once, include all the function declarations, and then include a single statement #include "array_tools.tpp".

// array_tools.h
#pragma once

template <typename T>
bool all_zero( T array[], std::size_t capacity );

template <typename T>
bool all_non_zero( T array[], std::size_t capacity );

template <typename T>
bool has_zero( T array[], std::size_t capacity );

template <typename T>
bool has_non_zero( T array[], std::size_t capacity );

template <typename T>
void  left_shift( T array[], std::size_t capacity, std::size_t n );

template <typename T>
void right_shift( T array[], std::size_t capacity, std::size_t n );

template <typename T>
void  left_circular_shift( T array[], std::size_t capacity, std::size_t n );

template <typename T>
void right_circular_shift( T array[], std::size_t capacity, std::size_t n );

template <typename T>
void fill( T array[], std::size_t capacity, T value = T{} );

template <typename T>
T *shrink( T *array, std::size_t capacity );

template <typename T>
T *resize( T *array, std::size_t capacity, std:size_t new_capacity );

template <typename T>
T *interleave( T array_1[], std::size_t capacity_1,
               T array_2[], std::size_t capacity_2 );

template <typename T>
std::size_t      find( T array[], std::size_t capacity, T sought_value );

template <typename T>
std::size_t *find_all( T array[], std::size_t capacity, T sought_value );

template <typename T>
void partial_sums( T array[], std::size_t capacity );

template <typename T>
T *concatenate( T array_1[], std::size_t capacity_1,
                T array_2[], std::size_t capacity_2 );

template <typename T>
void reverse( T array[], std::size_t capacity );

template <typename T>
void permute( T array[], std::size_t *permutation_array, std::size_t capacity );

template <typename T>
void print( T array[], std::size_t capacity,
                       std::size_t max_leading = 0,
                       std::size_t max_trailing = 0,
                       char *opening_delimiter = "{",
                       char *closing_delimiter = "}",
                       char *separator = "," );

template <typename T>
void print( T array[], std::size_t capacity,
                       std::size_t max_leading = 0,
                       std::size_t max_trailing = 0,
                       std::string opening_delimiter = "{",
                       std::string closing_delimiter = "}",
                       std::string separator = "," );

#include "array_tools.tpp"

The file array_tools.tpp would contain all the function definitions.