Perché lo swapping di array multidimensionali non è nullo?

Question

Ho il seguente frammento di codice:

#include <algorithm> 
#include <iostream> 

int main(int argc, char** argv) { 
    int x[2][3]; 
    int y[2][3]; 

    using std::swap; 
    std::cout << noexcept(swap(x, y)) << "\n"; 

    return 0; 
} 

Utilizzando GCC 4.9.0, Questo stampa 0. Non capisco perché.

Secondo lo standard ci sono due overload per std::swap:

namespace std { 
    template<class T> void swap(T& a, T& b) noexcept(
     is_nothrow_move_constructible<T>::value && 
     is_nothrow_move_assignable<T>::value 
    ); 

    template<class T, size_t N> 
    void swap(T (&a)[N], T (&b)[N]) noexcept(noexcept(swap(*a, *b))); 
} 

Nella mia comprensione l'identificatore noexcept per l'array dovrebbe funzionare in modo ricorsivo per gli array multidimensionali.

Perché lo swapping di array multidimensionali non è noexcept?

---

Durante il tentativo di trovare un esempio minimo che si comporta ancora stranamente mi si avvicinò con il seguente:

#include <iostream> 

template<class T> struct Specialized  : std::false_type {}; 
template<>  struct Specialized<int> : std::true_type {}; 

template<class T>    void f(T& a) noexcept(Specialized<T>::value); 
template<class T, std::size_t N> void f(T (&a)[N]) noexcept(noexcept(f(*a))); 

int main(int argc, char** argv) { 
    int x, y[1], z[1][1]; 

    std::cout << noexcept(f(x)) << " " 
       << noexcept(f(y)) << " " 
       << noexcept(f(z)) << "\n"; 
} 

Utilizzando GCC 4.9.0 viene stampato 1 1 0, ma ancora una volta non capisco perché.

Answer 1

Questo sovraccarico:

template<class T, size_t N> 
void swap(T (&a)[N], T (&b)[N]) noexcept(noexcept(swap(*a, *b))); 

non è portata fino ;, quindi swap(*a, *b) non considera questo sovraccarico. Questo è causa di:

3.3.2/1 Il punto della dichiarazione per un nome è subito dopo la sua completa dichiaratore (clausola 8) e prima della sua inizializzazione (se presente) ...

e la le specifiche delle eccezioni fanno parte del dichiaratore.