How to read data from text file into int array of struct?

Please find below a full working solution, including the nonesense constraints from yout instructor.

So, we do here, what normally nobody would do.

• Usage of char arrays instead of strings (Why that? What a nonesense)
• Using plain old C-style arrays
• using magic numbers for array dimensions instead of dynamic sizes.
• using of raw pointer!
• using setters and getters for everthing, braking encapsualtion
• returning pointer to member variables

Thsi program is stongly dependent on the exact input format, which is also not good.

A more flexible approach would be better

#include <iostream>
#include <sstream>
#include <fstream>
#include <iterator>
#include <algorithm>

std::istringstream inputFile{ R"(Hertz 93619
2014 Toyota Tacoma 115.12 1
2012 Honda CRV 85.10 0
2015 Ford Fusion 90.89 0
2013 GMC Yukon 110.43 0
2009 Dodge Neon 45.25 1

Alamo 89502
2011 Toyota Rav4 65.02 1
2012 Mazda CX5 86.75 1
2016 Subaru Outback 71.27 0
2015 Ford F150 112.83 1
2010 Toyota Corolla 50.36 1

Budget 93035
2008 Ford Fiesta 42.48 0
2009 Dodge Charger 55.36 1
2012 Chevy Volt 89.03 0
2007 Subaru Legacy 59.19 0
2010 Nissan Maxima 51.68 1
)" };

constexpr size_t MakeAndModelSize = 256;
constexpr size_t MaxInputLineSize = 1024;
constexpr size_t ZipCodeSize = 5;
constexpr size_t InventorySize = 5;
constexpr size_t NameOfAgenySize = 25;

class RentalCar {

public:
    RentalCar() {
        std::fill(m_make, m_make + MakeAndModelSize, 0);
        std::fill(m_model, m_model + MakeAndModelSize, 0);
    };
    RentalCar(int y, char* make, char* model, float price, bool available) : m_year(y), m_price(price), m_available(available)  {
        std::copy_n(make, MakeAndModelSize, m_make);
        std::copy_n(model, MakeAndModelSize, m_model);
    }

    // I am breaking the whole encapsulation 
    // We make some more noensense and define setters and getters for everything. 
    // so, we can also make all data public . . .
    void setYear(int year) { m_year = year; }
    void setMake(char* make) { std::copy_n(make, MakeAndModelSize, m_make); } 
    void setModel(char* model) { std::copy_n(model, MakeAndModelSize, m_model); }
    void setPrice(float price) { m_price = price; }
    void setAvailable(bool avail) { m_available = avail; }
    int getYear() { return m_year; };
    char* getMake() { return m_make; }; 
    char* getModel() { return m_model; } 
    float getPrice() { return m_price;  }
    bool getAvailable() { return  m_available; };
    void print() { std::cout << *this;  } // This function is not needed. We overlaoded the inserter already for that purpose
    double estimateCost(int days) { return days * m_price * (m_available ? 1.0 : 0.0);}

    // Overload inserter and extractor
    friend std::ostream& operator << (std::ostream& os, const RentalCar& rc) {
        return os << rc.m_year << ' ' << rc.m_make << ' ' << rc.m_model << ' ' << rc.m_price << ' ' << rc.m_available;
    }

    friend std::istream& operator >> (std::istream& is, RentalCar& rc) {
        is >> rc.m_year >> rc.m_make >> rc.m_model >> rc.m_price >> rc.m_available;
        return is;
    }

protected:
    // The data of the car
    int m_year{};
    char m_make[MakeAndModelSize];   // Lord, forgive me, I am using a fixed size plain char array for a string
    char m_model[MakeAndModelSize];  // Lord, forgive me, I am using a fixed size plain char array for a string
    float m_price{ 0.0 };
    bool m_available{ false };
};


class RentalAgency {

public:
    // Extractor operator. Read all data from stream
    friend std::istream& operator >> (std::istream& is, RentalAgency& ra) {
        is >> ra.name ;
        std::copy_n(std::istream_iterator<char>(is), ZipCodeSize, ra.zipcode);
        // Read all inventory data
        std::copy_n(std::istream_iterator<RentalCar>(is), InventorySize, ra.inventory);
        return is;
    }

    // Inserter operator. Output Data
    friend std::ostream& operator << (std::ostream& os, const RentalAgency& ra) {

        // Show name and zip code
        os << ra.name << ' ';
        std::copy_n(ra.zipcode, ZipCodeSize, std::ostream_iterator<char>(os));
        os << '\n';
        // Print inventory data
        std::copy_n(ra.inventory, InventorySize, std::ostream_iterator<RentalCar>(os, "\n"));
        return os << '\n';
    }

protected:
    char name[NameOfAgenySize]{};
    int zipcode[ZipCodeSize]{};
    RentalCar inventory[InventorySize]{};
};

int main()
{
    RentalAgency ra1{};
    RentalAgency ra2{};
    RentalAgency ra3{};

    // Read all data
    inputFile >> ra1 >> ra2 >> ra3;

    // For verification. Write all data to std::cout
    std::cout << ra1 << ra2 << ra3;

    return 0;
}

Please note. I am overloading the extractor and inserter operator for the classes. With that, reading and writing is extremely easy. Please see in main.

Then I read from an istringstream. But that is the same as reading from a file. Here on SO I do not have files, so I choose this solution.