Прямой доступ к переменным

if(param == "pole_1")
    foo(&myStuct::pole_1);
else if
    ...

bool is_within_years( Film *film, int year_Max, int year_Mim){
if (year_Max <  year_Mim) swap(year_Max, year_Mim);
if( film->year <= year_Max &&  film->year >= year_Min) return true;
return false;
}

// ConsoleApplication52.cpp : Defines the entry point for the console application.
//
 
#include "stdafx.h"
#include <string>
#include <list>
#include <iostream>
#include <algorithm>
 
using namespace std;
typedef struct
{
    int Year;
    string Name;
} MyStruct;
 
 
list<MyStruct> get_by_param(MyStruct*, int, bool(*)(MyStruct));
 
int _tmain(int argc, _TCHAR* argv[])
{
    const int n = 3;
    MyStruct structs[n];
    structs[0].Name = "Hello";
    structs[1].Name = "World";
    structs[2].Name = "Again";
    structs[0].Year = 2012;
    structs[1].Year = 2013;
    structs[2].Year = 2013;
 
    list<MyStruct> by_name = get_by_param(structs, n, [](MyStruct s) { return s.Name == "Hello"; });
    cout << "GOT BY NAME HELLO" << endl;
    for_each(by_name.begin(), by_name.end(), [](MyStruct s) { cout << s.Name << " " << s.Year << endl; });
    cout << endl;
 
    list<MyStruct> by_year = get_by_param(structs, n, [](MyStruct s) { return s.Year == 2013; });
    cout << "GOT BY YEAR 2013" << endl;
    for_each(by_year.begin(), by_year.end(), [](MyStruct s) { cout << s.Name << " " << s.Year << endl; });
 
    return 0;
}
 
list<MyStruct> get_by_param(MyStruct* structs, int n, bool(*predicate)(MyStruct))
{
    list<MyStruct> result;
    for (int i = 0; i < n; i++)
    {
        if (predicate(structs[i]))
            result.push_back(structs[i]);
    }
    return result;
}

/////////////////////////////////////////////////////////////////////////////////////////
//А задача, собственно, простая.
//Придумал себе структуру фильм. Поля такие как 
//
//режиссер, 
//
//год, 
//
//страна 
//
//и т.д. Как видно, 
//есть и строковые поля, и чиловые. Нужно достать из массива только те фильмы, которые 
//отвечают параметрам запроса пользователя. К примеру, все фильмы 2000 года.
//Вот и получается, что нужно смотреть именно по полю год. Вот это поле и нужно передать в ф-цию. 
//С этим разобрались, да поля-то разных типов и не ясно было как в мап засунуть эти значения.
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>ё
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <set>
#include <sstream>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
/////////////////////////////////////////////////////////////////////////////////////////
T_str   const   EMPTY_STR   =   T_str();
int     const   EMPTY_NUM   =   std::numeric_limits<int>::min();
/////////////////////////////////////////////////////////////////////////////////////////
void  set_empty_val( T_str  &   str_val )
{
    str_val     =   EMPTY_STR;
}
/////////////////////////////////////////////////////////////////////////////////////////
void  set_empty_val( int    &   int_val )
{
    int_val     =   EMPTY_NUM;
}
/////////////////////////////////////////////////////////////////////////////////////////
struct  T_film
{
    //-----------------------------------------------------------------------------------
    T_str   name_prompt_;
    T_str   country_prompt_;
    T_str   director_prompt_;
    T_str   year_prompt_;
    //-----------------------------------------------------------------------------------
    T_str   name_;
    T_str   country_;
    T_str   director_;
    int     year_;
    //-----------------------------------------------------------------------------------
    T_film()
        :
        name_prompt_        ( "название"    ),
        country_prompt_     ( "страна"      ),
        director_prompt_    ( "режиссер"    ),
        year_prompt_        ( "год"         )
    {
        set_empty_val   ( name_        );
        set_empty_val   ( country_     );
        set_empty_val   ( director_    );
        set_empty_val   ( year_        );
    }
    //-----------------------------------------------------------------------------------
    void  print()                                                       const
    {
        std::cout   <<  name_                                       <<  std::endl
                    <<  country_                                    <<  std::endl
                    <<  director_prompt_    <<  ' ' <<  director_   <<  std::endl
                    <<  year_                                       <<  std::endl
                    <<  std::endl;
    }
    //-----------------------------------------------------------------------------------
    bool  operator< ( T_film    const   &   film )                      const
    {
        return      less_field                      ( name_,    film.name_  )
                ||      eq_field                    ( name_,    film.name_  )
                    &&  less_country_director_year  ( film );
    }
    //-----------------------------------------------------------------------------------
    bool  less_country_director_year( T_film    const   &   film )      const
    {
        return      less_field              ( country_,     film.country_   )
                ||      eq_field            ( country_,     film.country_   )
                    &&  less_director_year  ( film );
    }
    //-----------------------------------------------------------------------------------
    bool  less_director_year( T_film    const   &   film )              const
    {
        return      less_field     ( director_,     film.director_  )
                ||      eq_field   ( director_,     film.director_  )
                    &&  less_field ( year_,         film.year_      );
    }
    //-----------------------------------------------------------------------------------
    bool  operator== ( T_film    const   &   film )                     const
    {
        return      eq_field( name_,        film.name_      )
                &&  eq_field( country_,     film.country_   )
                &&  eq_field( director_,    film.director_  )
                &&  eq_field( year_,        film.year_      );
    }
    //-----------------------------------------------------------------------------------
    bool  operator!= ( T_film    const   &   film )                     const
    {
        return  !operator==( film );
    }
    //-----------------------------------------------------------------------------------
    template< typename  T >
    static  bool    eq_field
        (
            T   const   &   L,
            T   const   &   R
        )
    {
        return      eq_empty_val( L )
                ||  eq_empty_val( R )
                ||  L   ==  R;
    }
    //-----------------------------------------------------------------------------------
    static  bool    eq_empty_val( T_str     const   &   str_val )
    {
        return  str_val     ==  EMPTY_STR;
    }
    //-----------------------------------------------------------------------------------
    static  bool    eq_empty_val( int   int_val )
    {
        return  int_val     ==  EMPTY_NUM;
    }
    //-----------------------------------------------------------------------------------
    template< typename  T >
    static  bool    less_field
        (
            T   const   &   L,
            T   const   &   R
        )
    {
        return      !eq_field( L, R )
                &&  L < R;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::set < T_film  >   T_films;
/////////////////////////////////////////////////////////////////////////////////////////
void  input_val_from_str
    (
        T_str           &   val,
        T_str   const   &   str
    )
{
    val     =   str;
}
/////////////////////////////////////////////////////////////////////////////////////////
void  input_val_from_str
    (
        int             &   val,
        T_str   const   &   str
    )
{
    std::istringstream  ssin( str );
    ssin    >>  val;
}
/////////////////////////////////////////////////////////////////////////////////////////
template< typename  T >
void  print_prompt_and_input_val_not_eq_to_old_val_or_nothing
    (
        T_str   const   &   prompt,
        T               &   old_val
    )
{
    T   new_val;
 
    do
    {
        std::cout   <<  '\t'
                    <<  std::setw(13)
                    <<  std::left
                    <<  prompt
                    <<  ": ";
 
        T_str   str_val;
 
        std::cin.sync();
        getline( std::cin, str_val );
 
        if  (
                str_val.empty()
            )
        {
            return;
        }
 
        input_val_from_str
            (
                new_val,
                str_val
            );
    }
    while( new_val == old_val );
 
    old_val = new_val;
}
/////////////////////////////////////////////////////////////////////////////////////////
template< typename  T >
void  input_val_or_nothing_for_field_name
    (
        T               &   field_ref,
        T_str   const   &   field_name
    )
{
    print_prompt_and_input_val_not_eq_to_old_val_or_nothing
        (
            field_name,
            field_ref
        );
}
/////////////////////////////////////////////////////////////////////////////////////////
void  input_name_or_nothing( T_film   &   film )
{
    input_val_or_nothing_for_field_name
        (
            film.name_,
            film.name_prompt_
        );
}
/////////////////////////////////////////////////////////////////////////////////////////
void  input_country_or_nothing( T_film   &   film )
{
    input_val_or_nothing_for_field_name
        (
            film.country_,
            film.country_prompt_
        );
}
/////////////////////////////////////////////////////////////////////////////////////////
void  input_director_or_nothing( T_film   &   film )
{
    input_val_or_nothing_for_field_name
        (
            film.director_,
            film.director_prompt_
        );
}
/////////////////////////////////////////////////////////////////////////////////////////
void  input_year_or_nothing( T_film   &   film )
{
    input_val_or_nothing_for_field_name
        (
            film.year_,
            film.year_prompt_
        );
}
/////////////////////////////////////////////////////////////////////////////////////////
void  input_film_data( T_film   &   film )
{
    std::cout   <<  std::endl
                <<  std::endl
                <<  std::endl
                <<  "Введите данные для поиска фильма. Для пропуска поля вводите пустую строку."
                <<  std::endl;
 
    input_name_or_nothing      ( film );
    input_country_or_nothing   ( film );
    input_director_or_nothing  ( film );
    input_year_or_nothing      ( film );
}
/////////////////////////////////////////////////////////////////////////////////////////
void  print_selected_films
    (
        T_film      const   &   selector,
        T_films     const   &   films
    )
{
    T_films     selected_films;
 
    std::remove_copy_if
        (
            films.begin     (),
            films.end       (),
 
            std::inserter
                (
                    selected_films,
                    selected_films.begin()
                ),
 
            std::bind2nd    ( std::not_equal_to<T_film>(), selector )
        );
 
    std::cout   <<  std::endl;
 
    if  (
            selected_films.empty()
        )
    {
        std::cout   <<  "Фильмов по вашему запросу не найдено."
                    <<  std::endl;
    }
    else
    {
        std::cout   <<  "Выбранные фильмы:"
                    <<  std::endl;
 
        std::for_each
            (
                selected_films.begin    (),
                selected_films.end      (),
                std::mem_fun_ref        ( &T_film::print )
            );
    }//else
}
/////////////////////////////////////////////////////////////////////////////////////////
void  print_all_films( T_films  const   &   films )
{
    std::cout   <<  std::endl;
 
    if  (
            films.empty()
        )
    {
        std::cout   <<  "Введенных фильмов нет."
                    <<  std::endl;
    }
    else
    {
        std::cout   <<  "Введенные фильмы:"
                    <<  std::endl;
 
        std::for_each
            (
                films.begin         (),
                films.end           (),
                std::mem_fun_ref    ( &T_film::print )
            );
    }//else
}
/////////////////////////////////////////////////////////////////////////////////////////
template< typename  T >
void  print_prompt_and_input_not_empty_val
    (
        T_str   const   &   prompt,
        T               &   val
    )
{
    T_str   str_val;
 
    do
    {
        std::cout   <<  prompt;
        std::cin.sync();
        getline( std::cin, str_val );
    }
    while   (
                str_val.empty()
            );
 
    input_val_from_str
        (
            val,
            str_val
        );
}
/////////////////////////////////////////////////////////////////////////////////////////
void  input_films( T_films   &   films )
{
    int     films_total     =   0;
 
    print_prompt_and_input_not_empty_val
        (
            "Количество вводимых фильмов: ",
            films_total
        );
 
    std::cout   <<  "Введите данные о "
                <<  films_total
                <<  " фильмах:"
                <<  std::endl;
 
    for( int  i = 0; i < films_total; ++i )
    {
        T_film  cur_film;
 
        std::cout   <<  std::endl
                    <<  '#'
                    <<  i + 1
                    <<  std::endl;
 
        print_prompt_and_input_not_empty_val
            (
                cur_film.name_prompt_ + "\t: ",
                cur_film.name_
            );
 
        print_prompt_and_input_not_empty_val
            (
                cur_film.country_prompt_ + "\t\t: ",
                cur_film.country_
            );
 
        print_prompt_and_input_not_empty_val
            (
                cur_film.director_prompt_ + "\t: ",
                cur_film.director_
            );
 
        print_prompt_and_input_not_empty_val
            (
                cur_film.year_prompt_ + "\t\t: ",
                cur_film.year_
            );
 
        films.insert( cur_film );
    }//for
}
/////////////////////////////////////////////////////////////////////////////////////////
int  main()
{
    std::locale::global(std::locale(""));
 
    T_films     films;
    input_films     ( films );
    print_all_films ( films );
 
    for(;;)
    {
        T_film  selector;
 
        input_film_data( selector );
 
        print_selected_films
            (
                selector,
                films
            );
    }//for
}