Объясните, на что ругается компилятор, и как это понимать?

void error(string s)
{
    throw runtime_error(s);
}
 
int main()
try {
    vector<int> v;
    int x;
    string s = "Ошибка";
    while (cin>>x) v.push_back(x);
    if (!cin) error("Ошибка");
    for (int i = 0; i<=v.size(); ++i) cout << "v[" << i << "] == " << v[i] << endl;
}
//catch (out_of_range)
//{
//  cerr << "Ой! Ошибка диапазона!\n";
//  return 1;
//}
catch (exception& e)
{
    cerr << "runtime error: " << e.what() << '\n';
    return 1;
}
catch (...)
{
    cerr << "Ой: неизвестное исключение!\n";
    return 2;
}

if (!cin) error("Ошибка");

if (!cin) error(s);

inline void error(const string& s)
{
    throw runtime_error(s);
}
 
inline void error(const string& s, const string& s2)
{
    error(s+s2);
}
 
inline void error(const string& s, int i)
{
    ostringstream os;
    os << s <<": " << i;
    error(os.str());
}

int a = 4444774;
    int b = a;
    cout << b*a;

vector<int> v(3);
    try {
        cout << v.at(4); //если заменить на v[4], то ошибку заметит только отладчик и catch не сработает, следовательно [] исключение не бросает.
    }
    catch (out_of_range a) { 
        cout << "Выход за пределы!";
    }

#include <iostream>
#include <vector>
 
 
struct base
{
    base():m_var()
    {
        m_var.at(10);
    }
    
    std::vector<int> m_var;
};
 
struct sample: base
{
    // пример-иллюстрация 'function-try-block' для конструктора
    sample() try: base() {
        
        std::cout <<"body of sample`s constructor\n";
    
    }
    catch (const std::exception& e)
    {
        std::cout << "поймали исключение в конструкторе: " << e.what() << std::endl;
        
        std::cout << "\nВАЖНО!!! имейте ввиду, что даже если мы смогли "
                     "поймать исключение в конструкторе\n"
                     "и обработали его - мы все равно не сможем сохранить объекту жизнь\n"
                     "исключение все равно пролетит дальше\n"
                     "если снаружи не стоит ловушка - приложение погибнет"
                  << std::endl;
    }
};
 
 
// пример-иллюстрация 'function-try-block' для обычной функции
int main() try {
    
    try 
    {
        std::cout << "создаю объект... сейчас вылетит птичка..." << std::endl;
        sample s;
    }
    catch (const std::exception& e)
    {
        std::cout << "поймали птичку вылетевшую из конструктора!" << std::endl;
    }
     
    std::cout <<"\n\nтеперь ловим исключение в обычной функции..." << std::endl;
    
    std::vector<int> v;
    v.at(10);
    return 0;
}
catch (const std::exception& e)
{
    std::cout << "поймали исключение в функции main\n";
    std::cout << "main catched exception: " << e.what() << '\n';
    return 1;
}

main(){
    try{}catch(...){}
}

main() try{
 
}
catch(...){
 
}

struct Test
{
    
    ~Test() try{
        throw 1;
    }catch(...){//Исключение вылетит из деструктора
        return;
    }//только если дойдем до сюда, а мы не дойдем, т.к. return
};
 
int main()
{
    Test t;
}//Не получим исключения из деструктора

//g++  4.9.3
 
#include <iostream>
 
struct Base
{
    ~Base(){ throw 1; }
};
 
 
struct Test: Base
{
    
    ~Test() try{
        std::cout <<"ok\n";
    }catch(...){//Исключение вылетит из деструктора
        return;
    }// и мы умрем. никакой return нас не спасет
};
 
 
int main()
{
    std::cout << "Hello, world!\n";
    Test t;
} // до сюда мы уже не дойдем

catch(...){
        std::cout << "x" << std::endl;//Этого мы не увидим :)
        return;
    }