EJERCICIO 2 :) /*Ejercicio 2: Escriba una función llamada al_cuadrado() que calcule el cuadrado del valor que se le transmite y despliegue el resultado. La función deberá ser capaz de elevar al cuadrado números flotantes.*/ #include #include using namespace std; void pedir(); void al_cuadrado(float x); float num; int main(){ pedir(); al_cuadrado(num); return 0; getch(); } void pedir(){ coutnum; } void al_cuadrado(float x){ float total = x * x; cout
En ningún momento menciona que solicites un numero, solo que simplemente lo transmitas directamente como argumento a la hora de llamar a la función :).
Soy Estrada Delgado Valery Vianey del CECyT 14 Basicamente creo que es lo mismo para comenzar a introducir operaciones solo que lo unico distinto es que se le adjunta la funcion
el ejercicio 2 lo hice asi (Si me dan opiniones por favor): #include #include #include using namespace std; void al_cuadrado(int n){ coutn; int potencia=pow(n,2); cout
No sé si algunos se dieron cuenta, pero el ejercicio dice, desplegar, no dice retornar. //4. Realizar un programa al_cuadrado(), desplegando el valor, incluso un float... #include #include #include using namespace std; void Leer(); void al_cuadrado(float numero); float n; int main(){ Leer(); al_cuadrado(n);
//Elevador al cuadrado #include #include using namespace std; //Prototipos de funciones void pedirDatos(); void al_cuadrado(float X); float num1; int main () { cout
/*Ejercicio 2: Escriba una función llamada al_cuadrado() que calcule el cuadrado del valor que se le transmite y despliegue el resultado. La función deberá ser capaz de elevar al cuadrado números flotantes.*/ #include #include #include using namespace std; template void al_cuadrado(TIP num); int main(){ float num1; int num2; double num3; int band; coutband; switch(band){ case 1: coutnum2; al_cuadrado(num2); break; case 2: coutnum1; al_cuadrado(num1); break; case 3: coutnum3; al_cuadrado(num3); break; default: break; } getch(); return 0; } template void al_cuadrado(TIP num){ cout
mi propuesta de resolución para el ej2 es: //directivas preprocesador #include #include #include//necesaria para la potencia using namespace std; //prototipos de funciones, plantillas para tipo de dato general,... void alcuadrado(float base); //programa principal int main(){ //ctes y vbles float numero; //petición datos coutnumero; //resolución alcuadrado(numero);//paso el param a la fcion //muestra de resultados /*se lo dejo a la fcion*/
supongqamos que tienes 5 funciones o mas, Lo que hace la variable goblar es no estar mandando a cada funcion esa variable, porque eso es mas eficaz pornerla en global si es que la vas a ocupar en tdas las funciones :3 es mi punto de vista.
/*Ejercicio 2: Escriba una función llamada al_cuadrado() que calcule el cuadrado del valor que se le transmite y despliegue el resultado. La función deberá ser capaz de elevar al cuadrado números flotantes. */ #include #include #include using namespace std; //prototipos de la funciones void perdirNum(); void al_cuadrado(float x); float num; int main(){ al_cuadrado(num);
/*Ejercicio 2: Escriba una función llamada al_cuadrado() que calcule el cuadrado del valor que se le transmite y despliegue el resultado. La función deberá ser capaz de elevar al cuadrado números flotantes.*/ #include #include using namespace std; void pedirdatos(); void al_cuadrado(float x); float x; float y; int main(){ pedirdatos(); al_cuadrado(x); cout
Hola Alejandro, muy buenos tus vídeos. Sólo tengo una duda a la hora de diferenciar cuando hay que poner void. ¿Qué diferencia hay entre mostrar un resultado o desplegarlo?
si tienes por ejemplo una funcion int suma(int x, int y); , esta se lo puedes asignar a otra variable de esta manera: int variable = suma(a, b), pero si pones void esto no funcionaría
*Ejercicio 2.* - Inicio código. /* Ejercicio 2 Escriba una función llamada que calcule el cuadrado del valor que se le transmite y despliegue el resultado. La función deberá ser capaz de elevar al cuadrado números flotantes. */ #include #include #include using namespace std; void al_cuadrado(float x); float n1; int main(){ al_cuadrado(n1); getch(); return 0; } void al_cuadrado(float x){ float resultado=0; coutn1; resultado=pow(n1,2); cout
Profesor que tal, tengo duda, ¿cundo es recomendable utilizar una funcion con retorno de valor y una sin retorno de valor? en pocas palabras: función con retorno de valor Versus sin retorno de valor. Saludos y excelente su curso.
cuando solo necesites mostrar el resultado en pantalla de una operacion, es mejor usar la funcion sin retorno... Pero si necesitas usar el resultado de la operacion en otra operacion, es mejor usar la funcion con retorno...
Este video de esta plataforma me ayudo a retomar temas que no sabía y mejorar un poco en mi programación respecto a este programa aplicarlo en mis actividades CECyT_14_4IV5_Ivan_Emmanuel_S
Aqui mi aporte /*Ejercicio 2: Escriba una función llamada al_cuadrado() que calcule el cuadrado del valor que se le transmite y despliegue el resultado. La función deberá ser capaz de elevar al cuadrado números flotantes. */ #include #include #include using namespace std; //Variables globales float num1, num2; //Definicion de funcion void al_cuadrado(float num1) { float potencia; potencia = pow(num1, 2); cout
Aquí les dejo mi código para ayudarlos :D #include using namespace std; void pedirdatos(); void al_cuadrado(float x); float num1; int main() { pedirdatos(); al_cuadrado(num1);
Ejercicio 2. #include #include //Libreria que nos permite usar la funcion pow(numero,elevado) using namespace std; void al_cuadrado(float); int main(int argc, char *argv[]) { float n1; coutn1;
cualquier numero elevado a cualquier exponente #include #include #include using namespace std ; void pedirDatos(); void cuadrado(float x , float y); float base , expo; int main ( ){ pedirDatos(); cuadrado(base , expo);
/*Ejercicio 2: Escriba una función llamada al_cuadrado() que calcule el cuadrado del valor que se le transmite y despliegue el resultado. La función deberá ser capaz de elevar al cuadrado números flotantes.*/ #include #include #include using namespace std; float n1,n2; //plantilla de funcion float al_cuadrado(float n1); int main(){ cout
Dejare esto por aquí 🙋♂️🙋♂️ profesor esta es mi tarea #include #include #include using namespace std; void pedirdatos (); void al_cuadrado (float x); float elevar; int main(){ pedirdatos (); al_cuadrado (elevar);
Hola, así desarrollé el ejercicio 2: /*Funciones.2.Escriba una función llamada AlCuadrado(); que calcule el cuadrado del valor que se le transmite y despliegue el resultado La función deberá ser capaz de elevar al cuadrado números flotantes.*/ #include #include #include using namespace std; void AlCuadrado(float a); void PedirNumero(); float numero; int main(){ PedirNumero(); AlCuadrado(numero);
si si puedes y con este ejemplo seria mas facil pedir datos directo del main pero la idea de crear funciones es dividir el codigo en segmentos para que sea mas optimo, mas organizado y en caso de modificaciones o cambios o busqueda de errores se te haga mas facil realizarlo o buscarlo...esto se veria mucho mas util con un ejercicio mas complejo.
/* Ejercicio 2: Escriba una funcion llamada al_cuadrado() que calcule el cuadrado del valor que se le transmite y despliegue el resultado. La funcion deberá ser capaz de elevar al cuadrado numeros flotantes */ #include using namespace std; //plantilla de funcion template void al_cuadrado(tipo num); int main(){ al_cuadrado(2.5); return 0; } template void al_cuadrado(tipo num){ tipo cuadrado = num * num; cout
/* Ejercicio 2: Escriba una función llamada al_cuadrado() que calcule el cuadrado del valor que se le transmite y despliegue el resultado. La función deberá ser capaz de elevar al cuadrado números flotantes. */ #include using namespace std; //Variables globales float numero; //Prototipos de funciones void al_cuadrado(float numero); int main() { al_cuadrado(numero); return 0; } void al_cuadrado(float numero) { //Declaración de variables locales float cuadrado = 1; cout > numero; for(int i = 0; i < 2; i++) { cuadrado = cuadrado * numero; } cout
/* Ejercicio 2: Escriba una función llamada al_cuadrado() que calcule el cuadrado del valor que se le transmite y despliegue el resultado. La función deberá ser capaz de elevar al cuadrado números flotantes. */ #include #include #include using namespace std; void al_cuadrado(float); int main(){ float num;
Hay algo que todavía no logro entender, por ejemplo en el caso de las plantillas de función si no sabes que tipo de numero va a ingresar el usuario se supone que crear una que abarca las tres (int, float, double) pero si realizas el mismo ejercicio sin utilizar plantilla y solo creas la variable double va a realizar la operación sin importar el tipo de numero que ingrese el usuario sea decimal o no, un ejemplo para que lo compilen y entiendan de lo que hablo: #include #include #include using namespace std; int main() { double n1; //No importa el valor que ingreses, si es decimal o no va a realizar de la misma manera cout > n1; cout
Es para optimizar la función. Al usar el double, aún cuando solo es necesario un int, haces que sea más lenta la compilación, pues esto reserva más memoria de lo que enrealidad necesita
@@edwinwilliamyepezdiaz2295 Algo así me imaginaba, pero el resto del código que hay que incluir no haría mas lento el proceso de igual manera? gracias por responder
@@nagatoroijiranaide4408 Si, se termina haciendo un pasito mas que simplemente usar un double, pero es mejor que despediciar memoria usando double para todo, un int y float ocupan 4 bytes en memoria un double ocupa el doble. Se trata de optimizar al maximo el uso de recursos, porque cuando estes trabajando en proyectos mas grandes estos detalles se van a notar.
Una pregunta. ¿No deberíamos poner números decimales cuando el programa nos los pide ya que son variables tipo float? En su video ha puesto numeros enteros y por eso no me cuadra.
No es una obligación al tener una variable de tipo float poner números con decimal, más bien es una opción que el programador permite para el usuario. Si el programa requiere en algún punto sólo números enteros, usas variables de tipo int, si quieres que el usuario sea libre de elegir el número, ponlo float, o double, según la permisividad que el programa te permita
si quieren hacer mas corto hagan solo una funcion que haga todo resumido #include #include #include using namespace std; //prototipo de la funcion para que aparezca float num1,resultado; void al_cuadrado(float x); void pedirdatos(); int main() { pedirdatos(); al_cuadrado(num1); getch(); return 0; } void al_cuadrado(float x) { float multiplicacion = x * x; cout
/* Descripción: Escriba una función llamada al_cuadrado() que calcule el cuadrado del valor que se le transmite y despliegue el resultado. La función deberá ser capaz de elevar al cuadrado números flotantes. */ #include #include #include //#include //Librería de system("pause") y numero random; using namespace std; /* Private variables */ float numero, cuadrado; /* Private functions prototypes */ void ask_for_variables(); void al_cuadrado( float x ); void show_result( float x ); /*User Code Begin */ int main(){ ask_for_variables(); al_cuadrado( numero ); show_result( cuadrado ); //system("pause"); getch(); return 0; } void ask_for_variables(){ cout > numero; } void al_cuadrado( float x ){ cuadrado = pow(x,2); } void show_result( float x ){ cout
Este es mi codigo del ejercicio 2 #include #include using namespace std; void pedirDato(); void al_cuadrado(float x); float num; int main(){ pedirDato(); al_cuadrado(num);
TENGO UN PROBLEMA, tengo un error llamado Id returned 1 exit status, como compongo eso, solo me pasa con un archivo .cpp con los demas no, estara corrupto? y porque? y de estarlo como lo compongo? ayudaaaa
#include #include #include using namespace std; //Plantilla y Prototipo de la Función template void al_cuadrado(TIPOD numero); int main(){ system("cls");
int n1= 16; float n2= 2.2; al_cuadrado(n1); al_cuadrado(n2); getch(); return 0; } //Definición de la Función template void al_cuadrado(TIPOD numero) { numero= sqrt(numero); cout
/*Ejercicio 2: Escriba una función llamada al_cuadrado() que calcule el cuadrado del valor que se le transmite y despliegue el resultado. La función deberá ser capaz de elevar al cuadrado números flotantes.*/ #include using namespace std; void al_cuadrado(float); int main (){ float numero; coutnumero; al_cuadrado(numero); } void al_cuadrado(float numero){ float resultado; resultado=numero*numero; cout
Mal. Está pidiendo que se transmite, entonces deberías tener una funcion tipo *int* que pase como parametro el valor ingresado, para que luego ese valor sea utilizado en la funcion tipo *void* y se eleve al cuadrado. Así: #include #include #include using namespace std; int ingresar(float &xy); void al_cuadrado(float xy); main(){ float num;
Comparto mi código del ejercicio 2 con l@s panas :3: /*Ejercicio 2: Escriba una función llamada al_cuadrado() que calcule el cuadrado del valor que se le transmite y despliegue el resultado. La función deberá ser capaz de elevar al cuadrado números flotantes.*/ #include #include #include using namespace std; void pedirDatos(); float al_cuadrado(float a); float n1; int main() { pedirDatos(); cout
/*Escriba una funcion llamada al_cuadrado() que calcule el cuadrado del valor que se le transmite y despliegue el resultado. La funcion debera ser capaz de elevar al cuadrado numeros flotantes*/ #include #include using namespace std; //Prototipo de funcion void pedirDatos(); void al_cuadrado(float numero); float numero; int main() { cout numero; } void al_cuadrado(float numero) { float cuadrado = pow(numero, 2); cout
/* Escriba una función llamada al_cuadrado() que calcule el cuadrado del valor que se le transmite y despliegue el resultado. La función deberá ser capaz de elevar al cuadrado números flotantes. */ #include #include using namespace std; //Prototipo de Función void pedirDatos(); void al_cuadrado(float x); float numero; int main(){
porque cuando no le pongo ningun parametro a mi funcion me resulve el problema correctamente #include #include #include #include #include #include using namespace std; void pedirdatos(); void mul( ); float n1, n2; int main(){ pedirdatos(); mul(); // getch(); system("pause"); return 0;} void pedirdatos(){ coutn1>>n2; } void mul( ){ float resultado; resultado= n1*n2; cout
/*Ejercicio 2: Escriba una función llamada al_cuadrado(), que calcule el cuadrado del valor que se le transmite y despliegue el resultado. La función deberá ser capaz de elevar al cuadrado números flotantes.*/ #include//Em... usa #include #include y #include //esto es porque cree mi propia Libreria //que usa las mas usadas con stdio stdlib math.h iostream ,etc y si me dio pereza usar /* ok gracias >:v template void al_cuadrado(Flint x); int main(){ float N; coutN; al_cuadrado(N);
Mi propuesta de resolución para el ejercicio 1 antes de ver el video es: //directivas preprocesador #include #include using namespace std; //prototipos de funciones, plantillas para tipo de dato general,... void mult(float m1,float m2);//si es sin retorno, es void //programa principal int main(){ //ctes y vbles float num1,num2,multiplicacion; //petición datos coutnum2; //resolución mult(num1,num2);//paso los valores a la función //muestra resultados pantalla /* LO DEJO PARA LA FUNCIÓN*/ cout
Mi tarea /*2. Escriba una función llamada al_cuadrado() que calcule el cuadrado del valor que se le transmite y despliegue el resultado. La función deberá ser capaz de elevar al cuadrado números flotantes.*/ #include #include #include float n; void datos(){ printf("Digite un numero decimal: "); scanf("%f", &n); } void al_cuadrado(float x){ cuadrado = pow(x, 2); printf("El cuadrado del numero ingresado es: %f ", cuadrado); } int main(){ datos(); al_cuadrado(n); system("pause"); return 0; }
No se pero siempre me aparese este error: "[Error] field 'prom' has incomplete type" , aparece la línea de código 14 en rojo. #include #include using namespace std; struct Promedio{ float nota1, nota2, nota3; }; struct Alumno{ char nombre[20], sexo[10]; int edad; struct Promerdio prom; //la línea que aparece en rojo. }alumno1; int main(){ float promedio; cout
Necesito AYUDAAAAAAAAA!!!!!! Resulta que ya hice los dos ultimos ejercicios pero cuando compilo y me saleotro ejercicio que ya habia culminado, ya revise todas las lineas pero me sigue compilando como si fuera tres ejercicoos atras, que puedo hacer?
Al parecer como tengo todos los ejercicios juntos la funcion esta llamando a un archivo que habia compilado anteriormente, por favor confirmenme si esto es posible. gracias
@@vdafs1 Lo que pasa es que esta compilando un ejercicio anterior este problema a mi también me daba cuando usaba dev c++, en la parte superior en donde compilas aparece un chulito o como le dicen una palomita (no me refiero al animal sino a este "✓") le das ahí y debería ejecutar el programa en el que te encuentras actualmente, cuéntame si te funciona si no prueba con los del lado no me acuerdo bien, hace tiempo que no lo uso
como es la sentencia en el caso de utilizar una función sin retorno de valor pero quiero mostrar el resultado en la función principal... si alguien me ayuda gracias...
Si quieres mostrar el resultado en el main sin retornar valor se utiliza la funcion tipo void y adentro de esta utilizas el "cout". Si la quieres mostrar retornando valor en el main si o si debes usar una función tipos int, double o alguna que te devuelva el valor y luego lo guardas en una variable y la imprimes con el "cout".
#include #include //declaro la variable tipo float float valor; //hago el prototipo de la variable que pedira los datos void solicitar_datos(); //el prototipo de la variable que hara el calculo void al_cuadrado(); //la funcion principal, que se dedicará a solo llamar a las otras funciones int main(){ solicitar_datos(); al_cuadrado(); std::cout
alguien me puede decir en que me equivoque? #include"stdafx.h" #include #include using namespace std; void dato(); void cuadrado(float x); float digit; int main(){ void dato(); void cuadrado(digit); system("pause"); return 0; } void dato(){
💻 Apúntate al curso completo de Programación en C++:
LINK: goo.gl/7kML7Z
La verdad, enseñaste 20mil veces mejor que los profesores que tuve en la universidad que saben un montón pero no transmitirlo a los alumnos.
Concuerdo totalmente
de acuerdo totalmente,como un buen profe te cambia el mundo
muchas gracias
donde quiera que te encuentres Alejandro un fuerte abrazo y un millón de gracias por tu trabajo y manera de transmitir el conocimiento
super sencillo el 2do!!, me encanta este bloque! es verdad, reduce en gran porcentaje el tamaño de la función principal, muy bonito
Y siempre dire, ÉL siempre será mi profesor que me enseño a programar
Sabpe
Amen
Gracias hermano
#include
#include
using namespace std;
void al_cuadrado(float a);
void Datos();
float a;
int main(){
Datos();
al_cuadrado(a);
}
void al_cuadrado(float a){
cout
//Ejercicio 2 de Funciones
#include
#include
#include
using namespace std;
void datos();
void al_cuadrado(float x, float y);
float num1,num2;
int main(){
datos();
al_cuadrado(num1,num2);
system("pause");
return 0;
}
void datos(){
coutnum1;
}
void al_cuadrado(float x, float y){
float potencia= (pow(x,2));
cout
#include
#include
#include
using namespace std;
void al_cuadrado(float n);
int main(){
float num;
coutnum;
al_cuadrado(num);
getch();
return 0;
}
void al_cuadrado(float n){
float resultado = pow(n,2);
cout
EJERCICIO 2 :)
/*Ejercicio 2: Escriba una función llamada al_cuadrado()
que calcule el cuadrado del valor que se le transmite
y despliegue el resultado.
La función deberá ser capaz de elevar al cuadrado números flotantes.*/
#include
#include
using namespace std;
void pedir();
void al_cuadrado(float x);
float num;
int main(){
pedir();
al_cuadrado(num);
return 0;
getch();
}
void pedir(){
coutnum;
}
void al_cuadrado(float x){
float total = x * x;
cout
En ningún momento menciona que solicites un numero, solo que simplemente lo transmitas directamente como argumento a la hora de llamar a la función :).
Además, está en la descripción el problema solucionado.
Soy Estrada Delgado Valery Vianey del CECyT 14 Basicamente creo que es lo mismo para comenzar a introducir operaciones solo que lo unico distinto es que se le adjunta la funcion
Es increíble como un canal con de más de 53 mil suscriptores tiene tan pocos likes :(
No saben apreciar la calidad :3
Pensé lo mismo!
el ejercicio 2 lo hice asi (Si me dan opiniones por favor):
#include
#include
#include
using namespace std;
void al_cuadrado(int n){
coutn;
int potencia=pow(n,2);
cout
en lugar de int era float
aqui esta mi taerita :)
#include
#include
using namespace std;
// prototipos de funciones
void PedirCuadrado();
void al_cuadrado (float x);
float n;
int main(){
PedirCuadrado();
al_cuadrado(n);
return 0;
}
void PedirCuadrado(){
cout > n;
}
void al_cuadrado (float x){
float cuadrado = pow(x,2);
cout
pow no puede elevar números con punto de decimal
@@karinatorres5615 lo acabo de probrar con pow y me funciona para numeros con decimales. lo comparto por las dudas por si tienes alguna correccion:
@@karinatorres5615
#include
#include
#include
using namespace std;
void pedir_datos();
void elevar_2(float n1);
float n1;
int main(){
pedir_datos();
elevar_2(n1);
getch();
return 0;
}
void pedir_datos(){
coutn1;
}
void elevar_2(float n1){
float elevar_2;
elevar_2 = pow(n1,2);
cout
No sé si algunos se dieron cuenta, pero el ejercicio dice, desplegar, no dice retornar.
//4. Realizar un programa al_cuadrado(), desplegando el valor, incluso un float...
#include
#include
#include
using namespace std;
void Leer();
void al_cuadrado(float numero);
float n;
int main(){
Leer();
al_cuadrado(n);
getch();
return 0;
}
void Leer(){
coutn;
cout
//Elevador al cuadrado
#include
#include
using namespace std;
//Prototipos de funciones
void pedirDatos();
void al_cuadrado(float X);
float num1;
int main ()
{
cout
/*Ejercicio 2: Escriba una función llamada al_cuadrado()
que calcule el cuadrado del valor que se le transmite
y despliegue el resultado.
La función deberá ser capaz de elevar al cuadrado números flotantes.*/
#include
#include
#include
using namespace std;
template
void al_cuadrado(TIP num);
int main(){
float num1;
int num2;
double num3;
int band;
coutband;
switch(band){
case 1:
coutnum2;
al_cuadrado(num2);
break;
case 2:
coutnum1;
al_cuadrado(num1);
break;
case 3:
coutnum3;
al_cuadrado(num3);
break;
default: break;
}
getch();
return 0;
}
template
void al_cuadrado(TIP num){
cout
mi propuesta de resolución para el ej2 es:
//directivas preprocesador
#include
#include
#include//necesaria para la potencia
using namespace std;
//prototipos de funciones, plantillas para tipo de dato general,...
void alcuadrado(float base);
//programa principal
int main(){
//ctes y vbles
float numero;
//petición datos
coutnumero;
//resolución
alcuadrado(numero);//paso el param a la fcion
//muestra de resultados
/*se lo dejo a la fcion*/
cout
Por que no pedir los datos dentro de int main ?
supongqamos que tienes 5 funciones o mas, Lo que hace la variable goblar es no estar mandando a cada funcion esa variable, porque eso es mas eficaz pornerla en global si es que la vas a ocupar en tdas las funciones :3
es mi punto de vista.
Muy buen video , Cecyt 14 Luis Enrique Erro, Areli Mendoza, 4iv5
Es necesario crear una funcion para pedir los datos?
los ejercicios son importantes para ir practicado el tema,emanuel ha,cecyt 14,4IV5
/*Ejercicio 2: Escriba una función llamada al_cuadrado()
que calcule el cuadrado del valor que se le transmite y
despliegue el resultado. La función deberá ser capaz de
elevar al cuadrado números flotantes.
*/
#include
#include
#include
using namespace std;
//prototipos de la funciones
void perdirNum();
void al_cuadrado(float x);
float num;
int main(){
al_cuadrado(num);
getch();
return 0;
}
//funciones
void al_cuadrado(float x){
coutx;
float resul = pow(x,2);
cout
/*Ejercicio 2: Escriba una función llamada al_cuadrado() que calcule
el cuadrado del valor que se le transmite y despliegue el resultado.
La función deberá ser capaz de elevar al cuadrado números flotantes.*/
#include
#include
using namespace std;
void pedirdatos();
void al_cuadrado(float x);
float x;
float y;
int main(){
pedirdatos();
al_cuadrado(x);
cout
Hola Alejandro, muy buenos tus vídeos. Sólo tengo una duda a la hora de diferenciar cuando hay que poner void. ¿Qué diferencia hay entre mostrar un resultado o desplegarlo?
si tienes por ejemplo una funcion int suma(int x, int y); , esta se lo puedes asignar a otra variable de esta manera: int variable = suma(a, b), pero si pones void esto no funcionaría
EJERCICIO 2: Admite exponentes enteros negativos
--------------------------------------------------------------------------------------------
#include
#include
using namespace std;
void datos();
void al_cuadrado(float x, int y);
float num;int i,n,stop=3;
int main(){
system("color 0F");
datos();
al_cuadrado(num,n);
return 0;
}
void datos(){
coutnum;
coutn;
}
void al_cuadrado(float x,int y){
float resultado=1;
if(y>=0 && x!=0){
for(i=0;i
*Ejercicio 2.*
- Inicio código.
/* Ejercicio 2
Escriba una función llamada que calcule el cuadrado del valor que se le transmite y despliegue el resultado.
La función deberá ser capaz de elevar al cuadrado números flotantes.
*/
#include
#include
#include
using namespace std;
void al_cuadrado(float x);
float n1;
int main(){
al_cuadrado(n1);
getch();
return 0;
}
void al_cuadrado(float x){
float resultado=0;
coutn1;
resultado=pow(n1,2);
cout
Profesor que tal, tengo duda, ¿cundo es recomendable utilizar una funcion con retorno de valor y una sin retorno de valor? en pocas palabras: función con retorno de valor Versus sin retorno de valor. Saludos y excelente su curso.
cuando solo necesites mostrar el resultado en pantalla de una operacion, es mejor usar la funcion sin retorno... Pero si necesitas usar el resultado de la operacion en otra operacion, es mejor usar la funcion con retorno...
Este video de esta plataforma me ayudo a retomar temas que no sabía y mejorar un poco en mi programación respecto a este programa aplicarlo en mis actividades
CECyT_14_4IV5_Ivan_Emmanuel_S
EJERCICIO 2:
#include
#include
#include
using namespace std;
void numero();
void al_cuadrado(float x);
float n;
int main(){
numero();
al_cuadrado(n);
getch();
return 0;
}
void numero(){
cout>n;
}
void al_cuadrado(float x){
float cuad;
cuad=pow(n,2);
cout
Aqui mi aporte
/*Ejercicio 2: Escriba una función llamada al_cuadrado()
que calcule el cuadrado del valor que se le transmite y
despliegue el resultado. La función deberá ser capaz de
elevar al cuadrado números flotantes.
*/
#include
#include
#include
using namespace std;
//Variables globales
float num1, num2;
//Definicion de funcion
void al_cuadrado(float num1) {
float potencia;
potencia = pow(num1, 2);
cout
Excelente video, muchas gracias... mi tarea:
/*Ejercicio 2*/
#include
#include
#include
using namespace std;
void pedirDatos();
void al_cuadrado(float x);
float numero;
int main(){
pedirDatos();
al_cuadrado(numero);
getch();
return 0;
}
void pedirDatos(){
coutnumero;
}
void al_cuadrado(float x){
float potencia = pow(x,2);
cout
Aquí les dejo mi código para ayudarlos :D
#include
using namespace std;
void pedirdatos();
void al_cuadrado(float x);
float num1;
int main() {
pedirdatos();
al_cuadrado(num1);
return 0;
}
void pedirdatos(){
coutnum1;
}
void al_cuadrado(float x){
float cuadrado = x*x;
cout
Ejercicio 2.
#include
#include //Libreria que nos permite usar la funcion pow(numero,elevado)
using namespace std;
void al_cuadrado(float);
int main(int argc, char *argv[]) {
float n1;
coutn1;
al_cuadrado(n1);
return 0;
}
void al_cuadrado(float numero){
cout
#include
#include
using namespace std;
//prototipos de funcion
void pedirdatos();
void al_cuadrado(float a);
float num;
int main(){
pedirdatos();
al_cuadrado(num);
return 0;
}
void pedirdatos(){
coutnum;
}
void al_cuadrado(float a){
float cuadrado=pow(num,2);
cout
cualquier numero elevado a cualquier exponente
#include
#include
#include
using namespace std ;
void pedirDatos();
void cuadrado(float x , float y);
float base , expo;
int main ( ){
pedirDatos();
cuadrado(base , expo);
getch();
return 0;
}
void pedirDatos(){
coutbase>>expo;
cout
Pow no eleva decimales
#include
#include
using namespace std;
void pedirnumero();
float elevador(float a);
float numero,resultado;
int main(){
pedirnumero();
elevador(numero);
cout
/*Ejercicio 2: Escriba una función llamada al_cuadrado()
que calcule el cuadrado del valor que se le transmite y
despliegue el resultado. La función deberá ser capaz de
elevar al cuadrado números flotantes.*/
#include
#include
#include
using namespace std;
float n1,n2;
//plantilla de funcion
float al_cuadrado(float n1);
int main(){
cout
Dejare esto por aquí 🙋♂️🙋♂️ profesor esta es mi tarea
#include
#include
#include
using namespace std;
void pedirdatos ();
void al_cuadrado (float x);
float elevar;
int main(){
pedirdatos ();
al_cuadrado (elevar);
getch();
return 0;
}
void pedirdatos (){
cout
Hola, así desarrollé el ejercicio 2:
/*Funciones.2.Escriba una función llamada AlCuadrado(); que calcule
el cuadrado del valor que se le transmite y despliegue el resultado
La función deberá ser capaz de elevar al cuadrado números flotantes.*/
#include
#include
#include
using namespace std;
void AlCuadrado(float a);
void PedirNumero();
float numero;
int main(){
PedirNumero();
AlCuadrado(numero);
system("pause");
return 0;
}
void PedirNumero(){
cout numero;
}
void AlCuadrado(float a){
float cuadrado;
cuadrado = pow(a,2);
cout
una pregunta en la función main no podría ir el pedir los datos q pedí al usuario sin necesidad de crear una funcion
si si puedes y con este ejemplo seria mas facil pedir datos directo del main pero la idea de crear funciones es dividir el codigo en segmentos para que sea mas optimo, mas organizado y en caso de modificaciones o cambios o busqueda de errores se te haga mas facil realizarlo o buscarlo...esto se veria mucho mas util con un ejercicio mas complejo.
ejercicio numero2:
#include
#include
#include
using namespace std;
void pedirDatos();
void al_cuadrado(float x, float y);
float num1,num2;
float potencia = 2;
int main(){
pedirDatos();
al_cuadrado(num1,num2);
getch();
return 0;
}
void pedirDatos(){
coutnum1;
coutnum2;
}
void al_cuadrado(float x, float y){
float elevado = pow(x,potencia);
float elevado2= pow(y,potencia);
cout
/* Ejercicio 2: Escriba una funcion llamada al_cuadrado() que calcule el cuadrado
del valor que se le transmite y despliegue el resultado. La funcion deberá ser
capaz de elevar al cuadrado numeros flotantes */
#include
using namespace std;
//plantilla de funcion
template
void al_cuadrado(tipo num);
int main(){
al_cuadrado(2.5);
return 0;
}
template
void al_cuadrado(tipo num){
tipo cuadrado = num * num;
cout
/*
Ejercicio 2: Escriba una función llamada al_cuadrado() que calcule el cuadrado del valor que se le transmite y despliegue el resultado.
La función deberá ser capaz de elevar al cuadrado números flotantes.
*/
#include
using namespace std;
//Variables globales
float numero;
//Prototipos de funciones
void al_cuadrado(float numero);
int main()
{
al_cuadrado(numero);
return 0;
}
void al_cuadrado(float numero)
{
//Declaración de variables locales
float cuadrado = 1;
cout > numero;
for(int i = 0; i < 2; i++)
{
cuadrado = cuadrado * numero;
}
cout
/*
Ejercicio 2: Escriba una función llamada al_cuadrado() que calcule el cuadrado del valor
que se le transmite y despliegue el resultado. La función deberá ser capaz de elevar
al cuadrado números flotantes.
*/
#include
#include
#include
using namespace std;
void al_cuadrado(float);
int main(){
float num;
coutnum;
al_cuadrado(num);
getch();
return 0;
}
void al_cuadrado(float elevado)
{
cout
Hay algo que todavía no logro entender, por ejemplo en el caso de las plantillas de función si no sabes que tipo de numero va a ingresar el usuario se supone que crear una que abarca las tres (int, float, double) pero si realizas el mismo ejercicio sin utilizar plantilla y solo creas la variable double va a realizar la operación sin importar el tipo de numero que ingrese el usuario sea decimal o no, un ejemplo para que lo compilen y entiendan de lo que hablo:
#include
#include
#include
using namespace std;
int main()
{
double n1;
//No importa el valor que ingreses, si es decimal o no va a realizar de la misma manera
cout > n1;
cout
Es para optimizar la función. Al usar el double, aún cuando solo es necesario un int, haces que sea más lenta la compilación, pues esto reserva más memoria de lo que enrealidad necesita
@@edwinwilliamyepezdiaz2295 Algo así me imaginaba, pero el resto del código que hay que incluir no haría mas lento el proceso de igual manera? gracias por responder
@@nagatoroijiranaide4408 Si, se termina haciendo un pasito mas que simplemente usar un double, pero es mejor que despediciar memoria usando double para todo, un int y float ocupan 4 bytes en memoria un double ocupa el doble.
Se trata de optimizar al maximo el uso de recursos, porque cuando estes trabajando en proyectos mas grandes estos detalles se van a notar.
Una pregunta. ¿No deberíamos poner números decimales cuando el programa nos los pide ya que son variables tipo float? En su video ha puesto numeros enteros y por eso no me cuadra.
No es una obligación al tener una variable de tipo float poner números con decimal, más bien es una opción que el programador permite para el usuario. Si el programa requiere en algún punto sólo números enteros, usas variables de tipo int, si quieres que el usuario sea libre de elegir el número, ponlo float, o double, según la permisividad que el programa te permita
si quieren hacer mas corto hagan solo una funcion que haga todo resumido
#include
#include
#include
using namespace std;
//prototipo de la funcion para que aparezca
float num1,resultado;
void al_cuadrado(float x);
void pedirdatos();
int main()
{
pedirdatos();
al_cuadrado(num1);
getch();
return 0;
}
void al_cuadrado(float x)
{
float multiplicacion = x * x;
cout
//Ejercicio Resuelto:
#include
#include
#include
using namespace std;
//Directivas del preprosesador
void al_cuadrado(float x);
float indice = 0;
//Main
int main(){
cout
/*
Descripción: Escriba una función llamada al_cuadrado() que calcule el cuadrado del valor que se le transmite
y despliegue el resultado. La función deberá ser capaz de elevar al cuadrado números flotantes.
*/
#include
#include
#include
//#include //Librería de system("pause") y numero random;
using namespace std;
/* Private variables */
float numero, cuadrado;
/* Private functions prototypes */
void ask_for_variables();
void al_cuadrado( float x );
void show_result( float x );
/*User Code Begin */
int main(){
ask_for_variables();
al_cuadrado( numero );
show_result( cuadrado );
//system("pause");
getch();
return 0;
}
void ask_for_variables(){
cout > numero;
}
void al_cuadrado( float x ){
cuadrado = pow(x,2);
}
void show_result( float x ){
cout
#include
#include
#include
using namespace std;
void al_cuadrado(float num);
int main(){
float num;
cout > num;
al_cuadrado(num);
getch();
return 0;
}
void al_cuadrado(float num){
cout
Este es mi codigo del ejercicio 2
#include
#include
using namespace std;
void pedirDato();
void al_cuadrado(float x);
float num;
int main(){
pedirDato();
al_cuadrado(num);
cout
Bien! pero para usar pow no hace falta la libreria math.h
//Ejercicio2 funciones
#include
using namespace std;
//Prototipo
template
TYPE al_cuadrado(TYPE a);
int main(){
float num, res;
coutnum;
res = al_cuadrado(num);
cout
TENGO UN PROBLEMA, tengo un error llamado Id returned 1 exit status, como compongo eso, solo me pasa con un archivo .cpp con los demas no, estara corrupto? y porque? y de estarlo como lo compongo? ayudaaaa
#include
using namespace std;
float mult(float a);
int main()
{
float x;
mult(x);
return 0;
}
float mult(float a){
float producto=1;
couta;
producto=a*a;
cout
#include
#include
#include
using namespace std;
void al_cuadrado(float x);
float num;
int main(int argc, char *argv[]) {
al_cuadrado(num);
getch ();
return 0;
}
void al_cuadrado(float x){
float cuadrado;
coutx;
cuadrado = pow(x,2);
cout
#include
#include
#include
using namespace std;
//Plantilla y Prototipo de la Función
template
void al_cuadrado(TIPOD numero);
int main(){
system("cls");
int n1= 16;
float n2= 2.2;
al_cuadrado(n1);
al_cuadrado(n2);
getch();
return 0;
}
//Definición de la Función
template
void al_cuadrado(TIPOD numero)
{
numero= sqrt(numero);
cout
Es fácil de aprender con estos ejercicios
Me agradan
Ximena M 4IV5 cecyt 14
/*Ejercicio 2: Escriba una función llamada al_cuadrado() que calcule el cuadrado del valor que se le transmite
y despliegue el resultado. La función deberá ser capaz de elevar al cuadrado números flotantes.*/
#include
using namespace std;
void al_cuadrado(float);
int main (){
float numero;
coutnumero;
al_cuadrado(numero);
}
void al_cuadrado(float numero){
float resultado;
resultado=numero*numero;
cout
Mal. Está pidiendo que se transmite, entonces deberías tener una funcion tipo *int* que pase como parametro el valor ingresado, para que luego ese valor sea utilizado en la funcion tipo *void* y se eleve al cuadrado.
Así:
#include
#include
#include
using namespace std;
int ingresar(float &xy);
void al_cuadrado(float xy);
main(){
float num;
ingresar(num);
al_cuadrado(num);
getch();
return 0;
}
int ingresar(float &xy)
{
cout > xy;
return xy;
}
void al_cuadrado(float xy)
{
float num_potenciado;
num_potenciado = pow(xy,2);
cout
TAREA:
#include
#include
using namespace std;
void al_cuadrado(float x);
float a;
int main(){
al_cuadrado(a);
system("pause");
return 0;
}
void al_cuadrado(float x){
coutx;
float res = x*x;
cout
Comparto mi código del ejercicio 2 con l@s panas :3:
/*Ejercicio 2: Escriba una función llamada al_cuadrado()
que calcule el cuadrado del valor que se le transmite y despliegue el resultado.
La función deberá ser capaz de elevar al cuadrado números flotantes.*/
#include
#include
#include
using namespace std;
void pedirDatos();
float al_cuadrado(float a);
float n1;
int main()
{
pedirDatos();
cout
nos volvemos a ver... gracias
@@SinNombre-dg3ls Hola de nuevo 😅, de nada ;).
/*Escriba una funcion llamada al_cuadrado() que calcule el cuadrado del valor que se le transmite
y despliegue el resultado. La funcion debera ser capaz de elevar al cuadrado numeros flotantes*/
#include
#include
using namespace std;
//Prototipo de funcion
void pedirDatos();
void al_cuadrado(float numero);
float numero;
int main() {
cout numero;
}
void al_cuadrado(float numero) {
float cuadrado = pow(numero, 2);
cout
/* Escriba una función llamada al_cuadrado() que calcule el cuadrado del
valor que se le transmite y despliegue el resultado. La función deberá ser
capaz de elevar al cuadrado números flotantes. */
#include
#include
using namespace std;
//Prototipo de Función
void pedirDatos();
void al_cuadrado(float x);
float numero;
int main(){
pedirDatos();
al_cuadrado(numero);
getch ();
return 0;
}
void pedirDatos(){
coutnumero;
}
void al_cuadrado(float x){
float multiplicacion = x*x;
cout
Una pregunta fuera del contexto del tema, pero ¿cómo podría hacerle para que me separe los millares en las cantidades cuando se muestra en pantalla?
Podrias hacer algo como esto dentro de un bucle:
19900150%1000; //150
19900150/1000; //19900
19900%1000; //900
19900/1000; //19
cout
porque cuando no le pongo ningun parametro a mi funcion me resulve el problema correctamente
#include
#include
#include
#include
#include
#include
using namespace std;
void pedirdatos();
void mul( );
float n1, n2;
int main(){
pedirdatos();
mul();
// getch();
system("pause");
return 0;}
void pedirdatos(){
coutn1>>n2;
}
void mul( ){
float resultado;
resultado= n1*n2;
cout
Ejercicio 2:
#include
#include
#include
using std::cout; using std::cin; using std::endl;
//Declarando funcion(es)
template
void num_alCuadrado(Cuadrado num);
double num_1;
int main()
{
num_alCuadrado(num_1);
getch();
return 0;
}
template
void num_alCuadrado(Cuadrado num)
{
float cuadra;
cout > num_1;
while (num_1 == 0 || num_1 < 0)
{
cout > num_1;
}
cuadra = pow(num_1,2);
cout
#include
#include
#include
using namespace std;
//prototipo de funcion
void pedirDatos();
float al_cuadrado(float numero);
//variables globales
float numero,resultado;
int main(){
//llamda de funcion
pedirDatos();
al_cuadrado(numero);
cout
Aldebaran M.CECYT 14.4IV6.ESTE VIDEO ME ENSEYO HACER VOID SIN RETORTNO
/*Ejercicio 2: Escriba una función llamada al_cuadrado(),
que calcule el cuadrado del valor que se le transmite
y despliegue el resultado.
La función deberá ser capaz de elevar al cuadrado números flotantes.*/
#include//Em... usa #include #include y #include
//esto es porque cree mi propia Libreria
//que usa las mas usadas con stdio stdlib math.h iostream ,etc y si me dio pereza usar /* ok gracias >:v
template
void al_cuadrado(Flint x);
int main(){
float N;
coutN;
al_cuadrado(N);
getch();
return 0;
}
template
void al_cuadrado(Flint x){
x = pow(x,2);
cout
#include
#include
using namespace std;
void pedirDatos();
void al_cuadrado(float x);
float num;
int main() {
pedirDatos();
al_cuadrado(num);
_getch();
return 0;
}
void pedirDatos() {
cout > num;
}
void al_cuadrado(float x) {
cout
¿Es necesario poner prototipos?
No es necesario, pero si es una buena practica hacerlo
Mi propuesta de resolución para el ejercicio 1 antes de ver el video es:
//directivas preprocesador
#include
#include
using namespace std;
//prototipos de funciones, plantillas para tipo de dato general,...
void mult(float m1,float m2);//si es sin retorno, es void
//programa principal
int main(){
//ctes y vbles
float num1,num2,multiplicacion;
//petición datos
coutnum2;
//resolución
mult(num1,num2);//paso los valores a la función
//muestra resultados pantalla
/* LO DEJO PARA LA FUNCIÓN*/
cout
#include
#include
#include
using namespace std;
double al_cuadrado(double x);
int main(){
double num;
coutnum;
al_cuadrado(num);
getch();
return 0;
}
double al_cuadrado(double x){
cout
en que video paso lo de void?
#include
#include
using namespace std;
template
void al_cuadrado(TIPO numero);
void pedirDatos();
float n1;
int main(){
pedirDatos();
al_cuadrado(n1);
getch();
return 0;
}
void pedirDatos(){
coutn1;
}
template
void al_cuadrado(TIPO numero){
numero*=numero;
cout
Mi tarea
/*2. Escriba una función llamada al_cuadrado() que calcule el cuadrado del valor que se le transmite y despliegue el resultado. La función deberá ser capaz de elevar
al cuadrado números flotantes.*/
#include
#include
#include
float n;
void datos(){
printf("Digite un numero decimal: "); scanf("%f", &n);
}
void al_cuadrado(float x){
cuadrado = pow(x, 2);
printf("El cuadrado del numero ingresado es: %f
", cuadrado);
}
int main(){
datos();
al_cuadrado(n);
system("pause");
return 0;
}
Después de ver los 3 últimos vídeos, con el actual siendo el número 3, 3 veces cada uno, recién vengo a entender jajjaja
#include
#include
using namespace std;
template
void al_cuadrado(tipoD numero);
int main(){
float num1;
coutnum1;
al_cuadrado(num1);
return 0;
}
template
void al_cuadrado(tipoD numero){
numero=pow(numero,2);
cout
#include
#include
#include
#include
using namespace std;
void pedir_datos();
float al_cuadrado(float num1);
float num1;
int main (){
pedir_datos();
al_cuadrado(num1);
return 0;
}
void pedir_datos(){
cout
#include
#include
#include
using namespace std;
void solicitar();
void al_cuadrado(float x);
float num;
int main() {
solicitar();
al_cuadrado(num);
cout num;
}
void al_cuadrado(float x) {
cout
No se pero siempre me aparese este error: "[Error] field 'prom' has incomplete type" , aparece la línea de código 14 en rojo.
#include
#include
using namespace std;
struct Promedio{
float nota1, nota2, nota3;
};
struct Alumno{
char nombre[20], sexo[10];
int edad;
struct Promerdio prom; //la línea que aparece en rojo.
}alumno1;
int main(){
float promedio;
cout
Has puesto Struct Promerdio y debe ser Struct Promedio.
Necesito AYUDAAAAAAAAA!!!!!!
Resulta que ya hice los dos ultimos ejercicios pero cuando compilo y me saleotro ejercicio que ya habia culminado, ya revise todas las lineas pero me sigue compilando como si fuera tres ejercicoos atras, que puedo hacer?
Al parecer como tengo todos los ejercicios juntos la funcion esta llamando a un archivo que habia compilado anteriormente, por favor confirmenme si esto es posible.
gracias
@@vdafs1 Lo que pasa es que esta compilando un ejercicio anterior este problema a mi también me daba cuando usaba dev c++, en la parte superior en donde compilas aparece un chulito o como le dicen una palomita (no me refiero al animal sino a este "✓") le das ahí y debería ejecutar el programa en el que te encuentras actualmente, cuéntame si te funciona si no prueba con los del lado no me acuerdo bien, hace tiempo que no lo uso
Nagatoro Ijiranaide lo que hice fue borrar los ejecutables y listo
#include
#include
#include
using namespace std;
//Prototipo de la funcion
void perdirDatos();
void al_cuadrado(float x);
//Variables globales
float n;
int main(){
perdirDatos();
al_cuadrado(n);
getch();
return 0;
}
void pedirDatos(){
coutn;
}
void al_cuadrado(float x){
float elevacion = pow(x,2);
cout
#include
#include
#include
using namespace std;
void pedir_datos();
void al_cuadrado(float x);
float num;
int main(){
pedir_datos();
al_cuadrado(num);
getch();
return 0;
}
void pedir_datos(){
coutnum;
}
void al_cuadrado(float x){
float cuadrado = pow(x,2);
cout
#include
using namespace std;
void pedirnumero();
void al_cuadrado(float x);
float n1;
int main(){
pedirnumero();
al_cuadrado(n1);
return 0;
}
void pedirnumero(){
coutn1;
}
void al_cuadrado(float x){
float cuad;
cuad = x*x;
cout
#include
#include
using namespace std;
void pedirDatos();
void al_cuadrado(float x);
float num1;
int main(){
pedirDatos();
al_cuadrado(num1);
return 0;
}
void pedirDatos(){
coutnum1;
}
void al_cuadrado(float x){
float resultado = 0;
resultado = pow(num1,2);
cout
como es la sentencia en el caso de utilizar una función sin retorno de valor pero quiero mostrar el resultado en la función principal... si alguien me ayuda gracias...
Si quieres mostrar el resultado en el main sin retornar valor se utiliza la funcion tipo void y adentro de esta utilizas el "cout".
Si la quieres mostrar retornando valor en el main si o si debes usar una función tipos int, double o alguna que te devuelva el valor y luego lo guardas en una variable y la imprimes con el "cout".
#include
#include
using namespace std;
template
void cuadrado (TIPOD numero);
void datos();
double numero,cua;
int main(){
datos();
cuadrado(numero);
getch();
return 0;
}
void datos(){
coutnumero;
}
template
void cuadrado (TIPOD numero){
cua=numero*numero;
cout
#include
#include
#include
#include
using namespace std;
void al_cuadrado(float x);
int main (){
float num;
cout num;
al_cuadrado(num);
getch();
return 0;
}
void al_cuadrado(float x){
float elevado=pow(x,2);
cout
#include
#include
#include
using namespace std;
void PedirDatos();
void al_cuadrado(float x);
float a, result;
int main(){
PedirDatos();
al_cuadrado(a);
getch();
return 0;
}
void PedirDatos(){
couta;
}
void al_cuadrado(float x){
result = pow(x,2);
cout
#include
#include
#include
#include
using namespace std;
float alCuadrado(float num1);
float num1;
int main(){
cout
#include
#include
using namespace std;
void pedirdatos();
void al_cuadrado(float x);
float num1;
int main(){
pedirdatos();
al_cuadrado(num1);
getch();
return 0;
}
void pedirdatos(){
coutnum1;
}
void al_cuadrado(float x){
num1 = num1*num1;
cout
#include
using namespace std;
// funtions
template
Generico al_cuadrado(Generico Dato);
int main() {
int Dato;
double Dato2;
cout > Dato;
cout > Dato2;
cout
#include
#include
//declaro la variable tipo float
float valor;
//hago el prototipo de la variable que pedira los datos
void solicitar_datos();
//el prototipo de la variable que hara el calculo
void al_cuadrado();
//la funcion principal, que se dedicará a solo llamar a las otras funciones
int main(){
solicitar_datos();
al_cuadrado();
std::cout
hola una duda ...
se puede llamar a una funcion desde otra funcion ???
si se puede
#include
using namespace std;
void al_cuadrado(float num);
int main(){
float num;
coutnum;
al_cuadrado(num);
return 0;
}
void al_cuadrado(float num){
cout
alguien me puede decir en que me equivoque?
#include"stdafx.h"
#include
#include
using namespace std;
void dato();
void cuadrado(float x);
float digit;
int main(){
void dato();
void cuadrado(digit);
system("pause");
return 0;
}
void dato(){
cout > digit;
}
void cuadrado(float x){
float resul = 0;
resul = digit * digit;
cout
#include
using namespace std;
template
void al_cuadrado(TIPOD x);
float ingresar(float x);
int main() {
float x;
x = ingresar(x);
al_cuadrado(x);
return 0;
}
float ingresar(float x){
cout > x;
return x;
}
template
void al_cuadrado(TIPOD x){
cout
Gracias por tus videos soy Luis R del cecyt 14 4iv5
te amo
ejercicio 2 resuelto :D
#include
#include
#include
using namespace std;
void usuario();
void al_cuadrado(float x);
float num;
int main(){
usuario();
al_cuadrado(num);
getch();
return 0;
}
void usuario(){
coutnum;
}
void al_cuadrado(float x){
float cuadrado = pow(x,2);
cout
eso mero