funciones internas que se ocupan de las variables del ámbito

Question

tengo un fragmento de código como este:

std::list<boost::shared_ptr<Point> > left, right; 
// ... fill lists ... 

// now, calculate the angle between (right[0], right[1]) and (right[0], left[0]) 
double alpha = angle(*(right.begin()->get()), *(((++right.begin()))->get()), *(left.begin()->get())); 

std::cout << alpha * 180/M_PI << std::endl; 

if(alpha < 0){ 
    // do something with the lists, like reversing them. Especially the beginning and end of the lists may change in some way, but "left" and "right" are not reassigned. 
} 

// calculate the new alpha 
alpha = angle(*(right.begin()->get()), *(((++right.begin()))->get()), *(left.begin()->get())); 

Aparte de la magia de la subasta iterador que puede no ser demasiado obvoius aquí sin los comentarios, me gustaría definir una función double alpha() para reducir la duplicación. Pero debido a que el uso de esta función es muy específico, me gustaría que sea una función local. Lo ideal sería así:

int a, b; 
int sum(){ return a + b; } 
a = 5; b = 6; 
int s = sum(); // s = 11 
a = 3; 
s = sum(); // s = 9 now 

En lenguajes como Python esto sería perfectamente bien, pero ¿cómo hacer esto en C++?

EDIT:

Esto es lo que terminó con, especial gracias a @wilx y la bandera -std=c++0x compilador:

auto alpha = [&right, &left]() { 

    // not 100% correct due to my usage of boost::shared_ptr, but to get the idea 

    Point r_first = *(right.begin()); 
    Point l_first = *(left.begin()); 
    Point r_second = *(++right.begin()); 

    return angle(r_first, r_second, l_first); 
}; 


if(alpha() < 0) // fix it 

double new_alpha = alpha(); 

Answer 1

En este caso se recomienda usar una sobrecarga como angle2(std::list<Point> const &, etc.). Dos argumentos simples son mejores que los que tienes ahora.

Con C++ 11 puede usar lambdas que capten sus argumentos por referencia.

Si no puedes usar C++ 11 y te sientes aventurero, prueba Boost.Phoenix (parte de Boost.Spirit).

Answer 2

C++, por lo que yo sé, no lo permite. Puede limitar la contaminación del espacio de nombres creada al agregar el calificador estático al comienzo de la firma de la función para alfa, pero aún debe definirlo por separado.

Esto hará que el nombre se use solo dentro de ese archivo fuente. También podría definir una macro dentro de la función, teniendo cuidado de definirla si no desea la rareza del preprocesador más adelante.

int a, b; 
#define SUM() (a+b) 
int s=sum() 
#undef SUM 

Answer 3

C++ no soporta funciones anidadas, pero una solución puede ser hecho con clases de función restringidos:

void scopeFnc() 
{ 
    struct Inner 
    { 
    static int nestedFnc() { return 5; } 
    }; 

    int a = Inner::nestedFnc(); 
}