overload-resolution
¿Por qué no se llama a un método const público cuando el que no es const es privado?
Considere este código:
struct A
{
void foo() const
{
std::cout << "const" << std::endl;
}
... traño. ¿Crees que es consistente? Mi código funciona y luego agrego un método, y mi código de trabajo no compila en absoluto.
¿Por qué el número de elementos en una lista del inicializador causa un error de llamada ambiguo?
¿Por qué las dos primeras llamadas a doSomething están bien por el compilador, pero el uso de dos elementos en la lista caus ... ", "stack", "overflow"}); // OK
doSomething({"hello", "stack"}); // C2668 'doSomething': ambiguous call
return 0;
}
¿Cómo se determina la ambigüedad en el algoritmo de resolución de sobrecarga?
Estoy tratando de entender el método de resolución de sobrecarga.
¿Por qué es esto ambiguo:
void func(double, int, int, do ... n contra 1 coincidencia exacta y 3 conversiones.
Entonces, ¿por qué uno es ambiguo y uno no lo es? ¿Cuál es la lógica aquí?
¿Por qué el decaimiento del puntero tiene prioridad sobre una plantilla deducida?
Digamos que estoy escribiendo una función para imprimir la longitud de una cadena:
template <size_t N>
void foo(const ... ero, mientras que la plantilla sería una coincidencia exacta? ¿Hay alguna manera de asegurar que se llame a mi función array?
Resolución de sobrecarga del método C # no seleccionar la anulación genérica concreta
Este programa completo de C# ilustra el problema:
public abstract class Executor<T>
{
public abstract void Execut ... go anterior se simplificó para mostrar el patrón, la estructura real es un poco más complicada, pero el problema es el mismo.
¿Cuáles son las trampas de ADL?
Hace algún tiempo leí un artículo que explicaba varias trampas de la búsqueda dependiente de argumentos, pero ya no puedo enc ... cceso a cosas a las que no deberías tener acceso o algo así. Así que pensé en preguntar aquí: ¿cuáles son las trampas de ADL?
Resolución de sobrecarga peculiar con while (true)
Estaba implementando sobrecargas sync / async cuando me encontré con esta situación peculiar:
Cuando tengo una expresión la ... Console.WriteLine("func");
}
Salida:
Acción
func
Entonces, ¿cómo puede ser eso? ¿Hay alguna razón para ello?
std:: function falla al distinguir funciones sobrecargadas
Estoy tratando de entender por qué std::function no es capaz de distinguir entre funciones sobrecargadas.
#include <funct ... r objeto, ya que su constructor está templatizado, que es independiente del argumento de plantilla que pasó a std::function.
C++0x const RValue referencia como parámetro de función
Estoy tratando de entender por qué alguien escribiría una función que toma una referencia const rvalue.
En el ejemplo de có ... ::vector<std::string> &&p) { std::cout << "3"; }
int main()
{
func(createVector());
return 0;
}
Resolución de sobrecarga y matrices: ¿qué función se debe llamar?
Considere el siguiente programa:
#include <cstddef>
#include <cstdio>
void f(char const*&&) { std: ... n realmente completamente equivocados? ¿Qué sobrecarga es la correcta para ser seleccionada por el último borrador de C++0x?
String literal coincide con bool overload en lugar de std:: string
Estoy tratando de escribir una clase de C++ que tiene algunos métodos sobrecargados:
class Output
{
public:
static void ... g, utiliza la sobrecarga booleana cuando paso un valor no booleano?
EDIT: Vengo de un entorno C # / Java, ¡muy nuevo en C++!
Lambdas sobrecargadas en C++ y diferencias entre clang y gcc
Estoy jugando con un truco para sobrecargar lambdas en C++. Específicamente:
// For std::function
#include <functional&g ... ;
}
Todavía estoy interesado en entender por qué esta versión del sobrecargado código lambda funciona, pero la original no.
¿Por qué un valor de una enumeración con un tipo subyacente fijo de char se resuelve en fct(int) en lugar de fct(char)?
Este problema surgió al responder esta pregunta sobre la resolución de sobrecarga con enums.
Mientras que el caso de long l ... t?
Lo único que se me ocurre es que las promociones integrales se aplican recursivamente, pero nada de lo que veo lo obliga.
Ambigüedad que implica operador de conversión con plantilla y constructor de copia implícito
Clang y gcc difieren en el comportamiento para el siguiente código:
struct foo
{
foo(int);
};
struct waldo
{
templ ... de copia de foo:
struct foo
{
foo(int);
foo(const foo&) = delete;
};
El comportamiento sigue siendo el mismo.
Resolución de sobrecarga para el operador heredado de multiply()
Primero, considere este código C++:
#include <stdio.h>
struct foo_int {
void print(int x) {
printf("int ... r? Esperaría que el tipo lambda se comporte exactamente igual que un tipo definido manualmente con operator() sobrecargado...