Mensajes

El operador [] en vector no chequea la condición de out of range, y el estándar define esta situación como "undefined behavior", que es la forma que tiene de decir: no lo hagas, puede suceder cualquier cosa (algo malo, o peor: nada).

El Visual Studio hace una comprobación en modo debug, aunque no lo comprueba en modo release.

Una práctica más higiénica recomienda usar std::vector::at()

Ya sé lo que es un Karel...

Y con respecto al programa este, debe haber mejores formas de resolverlo, seguramente, pero a mí me ha salido así, y no me disgusta:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <vector>
#include <algorithm>
#include <optional>

std::optional<double> find_comun(const std::vector<double>& coordenadas)
{
   for (const auto i : { 1, 2, 3 }) {
       if (std::find(coordenadas.begin() + i, coordenadas.end(), coordenadas[i - 1]) != coordenadas.end()) {
           return coordenadas[i - 1];
       }
   }
   return {};
}

int main()
{
   std::vector<double> abscisas;
   std::vector<double> ordenadas;

   std::cout << "4 puntos (x, y):\n";
   double x, y;
   for (const auto i : { 0, 1, 2, 3 }) {
       std::cin >> x >> y;
       abscisas.push_back(x);
       ordenadas.push_back(y);
   }

   // el punto de encuentro será (abscisa_comun, ordenada_comun):
   std::cout << "punto de encuentro = ("
       << find_comun(abscisas).value_or(std::nan("")) << ", "
       << find_comun(ordenadas).value_or(std::nan("")) << ")";
}

Si dejas que la excepción se propague hasta main(), puedes terminar ahí el programa.

básicamente:

Código (cpp) [Seleccionar] Expandir

int main()
{
    try {
        f();
        return EXIT_SUCCESS; 
    }
    catch (...) {
        return EXIT_FAILURE;
    }
}

La respuesta correcta es la primera.

De acuerdo, siempre que no olvides

Código [Seleccionar] Expandir

#include <windows.h>

Una forma muy usada, en particular por MFC de Microsoft es el Debug_new donde se usan macros para detectar memory leaks, del tipo

#define DEBUG_NEW new(__FILE__, __LINE__)
#define new DEBUG_NEW

El artículo original, con todas las explicaciones, y el link de descarga de debug_new.h que implementa esta técnica está en

http://wyw.dcweb.cn/leakage.htm

Algo que yo modificaría es la función OrdenarPorFrecuencia()

Primero haría que hiciese una sola cosa, si dice que lo que hace es ordenar la lista por frecuencia, que haga eso y nada más. Luego vendrá otra función que la muestre.

En segundo lugar, revisaría los algoritmos buscando algo más directo, más claro y, de ser posible, más eficiente. Quiero decir, le pegaría duro.

Yo creo que no hay manera. "La Consola" no está entre las definiciones del lenguaje, hay flujos de entrada y de salida, pero Consola no. Siempre tendrás que usar alguna librería, del C o del C++.

write está en <unistd.h> para C, o la ostream::write del C++ en <ostream>

No podrás escapar.

No tengo en claro cómo es en C, pero en C++:

El estándar garantiza que un signed char puede ir desde -127 hasta +127, al menos.

0xFF (256) es de tipo int.
...
EDITO
NHAAAA, he dicho una tontería.commo dice el colega, 0xFF es 255,

(¡La pastilla!)

Pero bueno, 255.

De todos modos, el estándar garantiza que un tipo entero siempre pueda convertirse en cualquier otro tipo entero, en este caso, el int 255 puede convertirse en signed char. Pero, como ese valor excede el máximo signed char posible, el resultado de la operación queda "implementation defined" definido por la implementación; esto es: cada compilador hará lo que mejor le parezca, y al tuyo le ha parecido -1

[spaceship operator]

Un comentario para los que se atreven con el C++20:

Aunque todavía no está terminado de cocer, es el estándar que va a venir antes de fin de año. Y bien, en C++20 estará disponible le "spaceship operator", que formalmente se llama "three-way comparison", y hoy funciona en Visual Studio y la mayoría de los compiladores modernos en modo experimental.

En este caso, para comparar floats o doubles, que podrían llegar a ser NaN (not a number), se necesita una comparación de tipo "partial_ordering".

Bueno, no es que yo sea un experto en naves espaciales, pero vale en este caso:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <compare>

int main()
{
float a = 6.9f;
auto my_partial_ordering = a <=> 6.9f;

if (std::is_lt(my_partial_ordering)) {
std::cout << "a < 6.9";
}
else if (std::is_eq(my_partial_ordering)) {
std::cout << "a == 6.9";
}
else if (std::is_gt(my_partial_ordering)) {
std::cout << "a > 6.9";
}
}

 No he probado tu código, pero algo que no debes hacer es comparar floats o doubles con ninguno de los operadores <, ≤, ==, > o ≥
La razón es que lo que cuando escribes un número decimal, 6.9, por ejemplo, estás escribiendo en base 10, mientras que la máquina tiene que traducirlo a base 2 para poder operar, y luego lo volverá a traducir a base 10 para poder mostrártelo, pero... cuando pones algo así:

Código [Seleccionar] Expandir

float f = 6.9;
if (f ≤ 6.9) {
// etcétera
}
en primer lugar 6.9 es de tipo double, si quieres que sea float debes poner 6.9f; porque estarás comparando dos números con precisiones distintas.
Luego, aunque escribas

Código [Seleccionar] Expandir

float f = 6.9f;
esa primer traducción de decimal a binario la va a hacer el compilador, y esa representación en binario no es exacta, es como cuando con números decimales escribes 1/3, que en decimal es 0.33333... periódico, de modo que cuando quieras comparar 1/3 == 0.3333333, no te sorprenda que el resultado sea false.

Entonces, la regla general es que tanto doubles como floats no se comparan de esa manera. Y entonces ¿cómo? Yo no conozco una solución única que sirva para todos los casos, pero en tu contexto, para mí bastaría con:

Código (cpp) [Seleccionar] Expandir


if ((nota>=5)&& (nota<=6.998f)) {
      printf ("\nHas aprobado!!");
}

Y lo mismo habría que hacer con cada una de las comparaciones.

Pero ésta sería una solución simple para este contexto, en otros casos se requerirá mayor cuidado y complejidad. Puedes ver una discusión sobre este asunto en
https://stackoverflow.com/questions/17333/what-is-the-most-effective-way-for-float-and-double-comparison