Чтение текстового файла и его данных в разные переменные

bool Input()
{
    ifstream stream(filename);
    if (stream.bad()) return false;
}

bool Input()
{
    ifstream stream(filename);
    if (stream.bad()) return false;
}

#include <iostream>
#include <cstring>
 
int main() {
    // Допустим, строку уже получили
    const char* population = "population=11500000";
    
    int value = 0;
    sscanf(population, "population=%d", &value);
    std::cout << value << std::endl;
}

struct City
{
    std::string town;
    int population;
    std::vector <int> latitude;
    std::vector <int> longitude;
    std::vector <std::string> transport;
};
 
std::vector <City> cities();  // создаём массив cities структур типа City

std::vector <City> cities;  // создаём массив cities структур типа City

/////////////////////////////////////////////////////////////////////////////////////////
//считать данные из файла, вот например такой файл
//
//town=Москва
//population=11500000
//latitude=55,45,07
//longitude=37,36,56
//transport=метро,автобусы,трамваи
//
//town=Санкт-Петербург
//population=4880000
//latitude=59,53,39
//longitude=30,15,51
//transport=метро,трамваи,троллейбусы
//
//town=Пенза
//population=517311
//latitude=53,11,39
//longitude=45,00,00
//transport=автобусы,троллейбусы
//
//соответственно надо считывать только параметры и те что через запятую в разные переменные
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <fstream>
#include <iostream>
#include <iterator>
#include <locale>
#include <sstream>
#include <string>
#include <vector>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string             T_str;
typedef std::vector < T_str >   T_strings;
typedef std::vector < int   >   T_geo_coord;
/////////////////////////////////////////////////////////////////////////////////////////
struct  T_city
{
    //-----------------------------------------------------------------------------------
    static  const   char    SPACE_SYMB  =   ' ';
    static  const   char    EQ_SYMB     =   '=';
 
    T_str                   name_;
    int                     population_;
    T_geo_coord             latitude_;
    T_geo_coord             longitude_;
    T_strings               transport_modes_;
    //-----------------------------------------------------------------------------------
    friend  std::istream    &   operator>>
        (
            std::istream    &   istr,
            T_city          &   city
        )
    {
        read_official_word_and_eq_symb_from_stream                  ( istr );
        read_line_of_stream_in_val                                  ( istr,     city.name_              );
 
        read_official_word_and_eq_symb_from_stream                  ( istr );
        read_line_of_stream_in_val                                  ( istr,     city.population_        );
 
        read_official_word_and_eq_symb_from_stream                  ( istr );
        read_line_of_stream_with_punctuation_delimiters_in_vector   ( istr,     city.latitude_          );
 
        read_official_word_and_eq_symb_from_stream                  ( istr );
        read_line_of_stream_with_punctuation_delimiters_in_vector   ( istr,     city.longitude_         );
 
        read_official_word_and_eq_symb_from_stream                  ( istr );
        read_line_of_stream_with_punctuation_delimiters_in_vector   ( istr,     city.transport_modes_   );
 
        return  istr;
    }
    //-----------------------------------------------------------------------------------
    static  void    read_official_word_and_eq_symb_from_stream( std::istream    &   istr )
    {
        getline
            (
                istr,
                T_str(),
                EQ_SYMB
            );
    }
    //-----------------------------------------------------------------------------------
    template< typename  T >
    static  void    read_line_of_stream_in_val
        (
            std::istream    &   istr,
            T               &   val
        )
    {
        T_str               s;
        getline                     ( istr, s );
        std::istringstream  ssin    (s);
        ssin    >>  val;
    }
    //-----------------------------------------------------------------------------------
    template< typename  TT_vector >
    static  void    read_line_of_stream_with_punctuation_delimiters_in_vector
        (
            std::istream    &   istr,
            TT_vector       &   vector
        )
    {
        vector.clear();
        T_str   s;
        getline                             ( istr, s );
        replace_punctuation_with_spaces     (s);
        std::istringstream  ssin            (s);
 
        std::copy
            (
                std::istream_iterator< TT_vector::value_type >  ( ssin      ),
                std::istream_iterator< TT_vector::value_type >  (),
                std::back_inserter                              ( vector    )
            );
    }
    //-----------------------------------------------------------------------------------
    static  void    replace_punctuation_with_spaces( T_str  &   s )
    {
        std::replace_if
            (
                s.begin     (),
                s.end       (),
 
                []  ( char  c )
                {
                    return  std::ispunct
                                (
                                    c,
                                    std::locale("")
                                );
                },
                SPACE_SYMB
            );
    }
    //-----------------------------------------------------------------------------------
    friend  std::ostream    &   operator<<
        (
            std::ostream            &   ostr,
            T_city          const   &   city
        )
    {
        ostr    <<  city.name_          <<  std::endl
                <<  city.population_    <<  std::endl;
 
        write_in_ostream_vector( ostr,  city.latitude_          );
        write_in_ostream_vector( ostr,  city.longitude_         );
        write_in_ostream_vector( ostr,  city.transport_modes_   );
        ostr    <<  std::endl;
        return  ostr;
    }
    //-----------------------------------------------------------------------------------
    template< typename  TT_vector >
    static  void    write_in_ostream_vector
        (
            std::ostream            &   ostr,
            TT_vector       const   &   vector
        )
    {
        std::copy
            (
                vector.begin                                    (),
                vector.end                                      (),
                std::ostream_iterator< TT_vector::value_type >  ( ostr, " " )
            );
 
        ostr    <<  std::endl;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::vector < T_city    >   T_cities;
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
    const   T_str   TOWNS_FILE_NAME   =   "cities.txt";
    std::ifstream   ifile( TOWNS_FILE_NAME );
 
    if( !ifile )
    {
        std::cout   <<  "Файл \""
                    <<  TOWNS_FILE_NAME
                    <<  "\" не найден."
                    <<  std::endl;
    }//if
 
    T_cities    cities;
 
    std::copy
        (
            std::istream_iterator< T_city >     ( ifile     ),
            std::istream_iterator< T_city >     (),
            std::back_inserter                  ( cities    )
        );
 
    std::cout   <<  "Из файла \""
                    <<  TOWNS_FILE_NAME
                    <<  "\" считана информация о "
                    <<  cities.size()
                    <<  " городах:"
                    <<  std::endl
                    <<  std::endl;
 
    std::copy
        (
            cities.begin                        (),
            cities.end                          (),
            std::ostream_iterator< T_city >     ( std::cout )
        );
 
    system("pause");
}