Array without a specified size without using vector

Question

I am trying to make a program that reads files with numbers and sort the numbers with different algorithms and there is multiple files that are going to be read and each file has a different amount of integers. so what i need to do is read those integers and cast them into a array.

but for some reason in c++ you cant have a array with an undefined size so what is a solution that i can use? And i can't use vectors (school project)

Here is my program

#ifndef SORT_H
#define SORT_H
#include <iostream>
#include <fstream>
#include <string>

using namespace std;


// =============================================================================
// FILE READER
// =============================================================================
void fileReader(string fileName, int arr[]){

    ifstream myfile(fileName);

    int pos = 0;
    string number;
    if(myfile.is_open()){
        while (getline(myfile, number))
        {
            arr[pos] = stoi(number);
            pos++;
        }
        
    }
}
// =============================================================================
//  SWAPER
// =============================================================================

void swap(int* a, int* b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

// =============================================================================
// QUICKSORT
// =============================================================================



int partition(int arr[], int beg, int end){

    int pivot = arr[end];
    int index = beg - 1;
    
    for(int j = beg; j < end; j++){
    
        if(arr[j] <= pivot){
        
            index++;
            swap(&arr[index], &arr[j]);
            
        }
        
    }
    
    swap(&arr[index+1], &arr[end]);
    
    return (index+1);
}

void quicksortAlgo(int arr[], int beg, int end){
    
    if(beg < end){
        
        int pi = partition(arr, beg, end);
        
        quicksortAlgo(arr, beg, pi-1);
        quicksortAlgo(arr, pi+1, end);
        
    }
    
}

template <typename T>
void quicksort(T arr[], int n)
{
    quicksortAlgo(arr, 0, n-1);

    for(int x = 0; x < n; x++)
        cout << arr[x] << endl;
}


// =============================================================================
// HEAPSORT
// =============================================================================

void heapify(int arr[], int n, int i){
    int max = i;
    int left = 2*i + 1; // Left side
    int right = 2*i + 2;    // Right side
    
    cout << "max: " << arr[max] << endl;


    // if there is a left child for root and if is
    // bigger then root
    if(left < n && arr[max] < arr[left]){
        max = left;
    }
    
    // If there is a right child of root and if is
    //  bigger then root
    if(right < n && arr[max] < arr[right]){
        max = right;
    }
    
    if(max != i){
        swap(&arr[i], &arr[max]);
        heapify(arr, n, max);
    }


}


void heapsortAlgo(int arr[], int n){

    
        for (int i = n/2 - 1; i >= 0; i--){
            heapify(arr, n, i);
        }
        for (int i = n-1; i >= 0; i--){
            swap(&arr[0], &arr[i]);
            heapify(arr, i, 0);
        }
}

template <typename T>
void heapsort(T arr[], int n)
{
    heapsortAlgo(arr, n);
    for (int i = 0; i < n; i++){
        cout << arr[i] << " ";
    }
}

// =============================================================================
// INTSERTIONSORT
// =============================================================================
template <typename T>
void insertionsort(T arr[], int n)
{
    int holePostion;
    int valueToInsert;

    for (int i = 1; i < n; i++){
        valueToInsert = arr[i];
        holePostion = i;

        while(holePostion > 0 && arr[holePostion-1] > valueToInsert){
            arr[holePostion] = arr[holePostion - 1];
            holePostion = holePostion - 1;
        }

        arr[holePostion] = valueToInsert;
    }
}

int main(){
    string filedest;
    string arrSize;
    cout << "enter file destenation: ";
    cin >> filedest;

    int arr[];

    int n = sizeof(arr) / sizeof(arr[0]);

    fileReader(filedest, arr);

    quicksort(arr, n);


    return 0;
}

#endif

Answer 1

As @MikeCAT mentioned, you can use std::vector<T>.

You can add push elements at the back of the vector by std::vector<T>::push_back().

Alternatively, you can also resize the vector array by using std::vector<T>::resize() and then add elements at a specific location similar to what you are doing in your fileReader() function. You can also insert elements at a specific location by calling std::vector<T>::insert() .

Do have a look at the time complexities if you have a time constraint in your programming task.