Mensajes

["Hola mundo" en C que también compila en C++:]

En la poca experiencia que he tenido leyendo sobre c++ he visto que la mayoria de los autores habla de c++ como un superconjunto de c,a partir de lo anterior me crea la incertidumbre si esto es totalmente cierto o es una simplete exageracion

Según Stroustrup (http://www.stroustrup.com/bs_faq.html) el C++ es un descendiente directo del C y conserva casi todo el C como un subconjunto.

Eso implica que un programa C puede (con cambios, pocos o muchos) puede ser también un programa C++, pero no a la inversa.

El C++ nace (hace 30 años) a partir del C, y desde entonce siempre se ha tratado de conservar esa relativa "compatibilidad hacia atrás".

Cuando se habla de C/C++ no se está queriendo decir que se trata del mismo lenguaje ni de lenguajes similares, se está refiriendo a esa relación de descendencia de la que habla su autor.

En el caso de que sea asi se podria decir que desde el lenguaje c++ yo puedo hacer un programa exactamente igual que en c independientemente de la complejidad que tenga

En C++ puedes compilar un programa C, después de hacerle algunos cambios, esa es la idea de "Compatibilidad hacia atrás". Pero ni el más básico "hola mundo" en C++ se parece en nada a su versión en C.

"Hola mundo" en C que también compila en C++:

Código [Seleccionar] Expandir

#include <stdio.h>
int main()
{
printf("Hola Mundo!");
return 0;
}

"Hola mundo" en C++

Código [Seleccionar] Expandir

#include <iostream>
int main()
{
std::cout << "Hola Mundo! ";
}

En un programa de una línea ya se ve esa relación de una sola dirección. Si tienes un sistema de muchos miles de líneas en C, podrías mantenerlo mientras lo migras a C++. Si tienes miles de líneas en C++ y quieres pasarlo a C, tíralo y vuelve a escribirlo desde cero en C.


Otro mito: "el C++ es un lenguaje orientado a objetos".

No es así, nunca lo fue. Java es orientado a objetos, el C++ "soporta objetos", son conceptos muy diferentes.

Disculpa si sueno grosero, pero aprender un lenguaje de programación en un nivel básico como para decir que se manejan los rudimentos exige un esfuerzo considerable y necesita de una buena guía y referencias con la realidad. Poner esfuerzo sin guía y sin contacto con la realidad es peor que perder el tiempo.

No hay C/C++, hay C y hay C++, son dos lenguajes distintos.

El C++ es un lenguaje de alto nivel, si alguna vez se dijo que no, eso pudo haber sido antes del estándar de 1998 (si quieres puedes hacer la cuenta), y como lenguaje de alto nivel tiene todas esas "estructuras de datos" incluidas en su biblioteca estándar.

Por ejemplo:

• Contenedores de secuencias: array, vector, deque, forward_list, list.
  Contenedores asociativos: set, multiset, unordered_set, unordered_multiset, map, multimap, unordered_map, unordered_multimap
  Y adaptadores para contenedores: stack, queue, priority_queue.

No quiero decir que no valga la pena saber cómo se construyen estos contenedores, por supuesto, pero sin saber que el C++ es un lenguaje de alto nivel ya se está comenzando medio ciego y aturdido por prejuicios de hace más de 20 años (y atrasar 20 años en un lenguaje de programación es atrasar, créeme).

Hay un capítulo sobre contenedores y algoritmos del libro de Stroustrup "The C++ Programming Language" disponible gratis en:
https://isocpp.org/files/papers/4-Tour-Algo-draft.pdf

Si te interesa aprender el C++, ese es un libro que querrás leer.

Cuando dices "estructuras de datos en C++", ¿a qué te refieres? ¿Puedes poner un ejemplo o un sitio web donde hablen de eso?

Código [Seleccionar] Expandir

#include <iostream>
#include <vector>
#include <string>
#include <cstdlib>

struct prod
{
prod(std::string name, int precio, int id)
: name{ name }
, precio{ precio }
, id{ id }
{}

int precio;
int id;
std::string name;
std::string adc; // caracteristicas adicionales
};

void addpr(std::vector<prod>& vProd);
void db(std::vector<prod>& vProd);

int main()
{
std::vector<prod> vProd; // el "array" de productos

// ...
// ... etcétera
// ...

// añadir producto:
addpr(vProd);

// ...
// mostrar productos:
db(vProd);
}

void addpr(std::vector<prod>& vProd)
{
std::string name;
int precio;

std::cout << "inserte nombre del producto: ";
std::cin >> name;
std::cout << "inserte precio: ";
std::cin >> precio;

vProd.emplace_back(name, precio, std::rand());
}

void db(std::vector<prod>& vProd)
{
for (const auto& i : vProd) {
std::cout << "mombre: " << i.name << '\n'
<< "precio: " << i.precio << '\n'
<< "ID: " << i.id << "\n------------------------\n";
}
}

En C++ un array de dimensión dinámica es de preferencia un std::vector
https://es.cppreference.com/w/cpp/container/vector

La función que necesitas ya existe en la biblioteca estándar, es count_if
https://en.cppreference.com/w/cpp/algorithm/count

Código [Seleccionar] Expandir

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

auto diferentes(const std::vector<int>& arreglo, int ultimo)
{
// contar los números distintos a "ultimo"
return std::count_if(arreglo.begin(), arreglo.end(), [&ultimo](auto i) { return i != ultimo; });
}

int main()
{
// ejemplo
// en un arreglo se introducen 8 datos:
std::vector<int> arreglo{1, 1, 2, 2, 3, 4, 2, 1};

std::cout << diferentes(arreglo, 1);

}

Depende mucho del sistema operativo. En Windows se usa Visual Studio casi exclusivamente, y QT Creator si estás en QT, claro; después otros, pero mucho, muuucho menos. En Linux hay más variedad, Netbeans, CLion, QT Creator (si estás en QT, claro), Sublime, y alguno más.  Para Mac creo que igual, pero me parece que hay más fanáticos de CLion.