Bucles encajados

Aquí ponemos un programa para presentar en pantalla una tabla, en este caso de multiplicar, pero podría ser de cualquier otra cosa. Se hace mediante lo que se llama un par de bucles encajados. Es un problema clásico.

/*El uso de While. Tabla de multiplicar. Contiene 2 bucles anidados */
#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
  int i=2,j,k,m,R;
  cout<<endl;
  //**Impresión de cada línea de la tabla**
  while (i<=9){
    j=2;
    while (j<=9){
      cout<<i<<"*"<<j<<" ="<<setw(3)<<right<<i*j<<" | ";
      j++;
    }
    cout<<endl;
    //**Renglón**
    m=0;
    while (m<=7){
      if (m==0) R=8; else R=9;
      for(k=0;k<=R;k++) cout<<"-";
      cout<<"|";
      m++;
    }
    //-----------
    i++;
    cout<<endl;
  }
  //**Termina bucle principal**
  cout<<endl;
  return 0;
}

Fracción propia y decimal

Este programa convierte una fracción propia - aquella cuyo numerador es menor que el denominador - en una fracción decimal. El sistema no es directo, dividiendo un número por otro como números reales. Ahí está la gracia, sino que se tratan los dos números en todo momento como números enteros. En realidad es lo mismo que haríamos con lápiz y papel y un poco de paciencia, porque saca 20 decimales.

#include<iostream>
#define N 20
using namespace std;
int main()
{
long int dv,ds,q=1,Q,R;
int i,d[N];
for(i=0;i<N;i++) d[i]=0;
cout<<"\tVamos a transformar una fracción propia,\n"
<<"\ten la que el numerador es menor que el denominador,\n"
<<"\ten una decimal\n";
ini:
cout<<"Dame el numerador N de la fracción: ";
cin>>dv;
cout<<"Dame en denominador D de la fracción: ";
cin>>ds;
if(dv>=ds) {cout<<"¡Error, repita, por favor!\n";goto ini;}
//----
while(q*ds<=dv)
q++;
Q=q-1;
R=dv;
for(i=0;i<N;i++){
if(R==0) break; 
else {
dv=R*10;q=1;
while(q*ds<=dv)
q++;Q=q-1;
R=dv-Q*ds;
d[i]=Q;
}
}
cout<<"La fracción decimal es: 0,";
for(i=0;i<N;i++) cout<<d[i];
cout<<endl;
return 0;
}

Suma y resta atípicas

Nulla dies sine linea, decían los romanos. Así que no vamos a dejar pasar un día más sin poner algo aquí. Son programas sencillos que van señalando mis aventuras con el C++,  y los pongo aquí por si a alguien le sugieren algo.  Hoy traigo dos programas. Los llamo suma, resta atípicas, porque, como digo en los programas, las operaciones aritméticas - suma, resta, multiplicación y división - se reducen a contar hacia adelante o hacia atrás. Todo es contar al fin de cuentas. Creo que se podría demostrar que hasta las matemáticas más abstrusas en el fondo se reducen a los números naturales: 1, 2, 3,... infinito. Bueno, por el momento vamos a dejar estas filosofías para otro día. Estos dos programas suman y restan sencillamente contando mediante un bucle cuanto pasa o cuanto queda hasta un número determinado.

#include<iostream>
using namespace std;
int main()
{
long int m,n,i;
long int contador=0;
cout<<"\n\tSUMA ATÍPICA\n";
cout<<"\tLAS OPERACIONES ARITMÉTICAS SE REDUCEN SIEMPRE A CONTAR\n";
cout<<"\tHACIA ADELANTE O HACIA ATRÁS.\n";
init:
cout<<"\tDame el primer sumando: ";
cin>>m;
cout<<"\tDame el segundo sumando: ";
cin>>n;
cout<<"\tVamos a sumar "<<n<<" con "<<m<<endl;
contador=m;
for(i=0; i<n; i++)
contador++;
cout<<"\tHemos obtenido el resultado: "<<contador<<" \n"<<endl;
return 0;
}

_____________________________________________

#include<iostream>

using namespace std;

int main()

{

long int m,n,i;

long int contador=0;

cout<<"\n\tRESTA ATÍPICA\n";

cout<<"\tLAS OPERACIONES ARITMÉTICAS SE REDUCEN SIEMPRE A CONTAR\n";

cout<<"\tHACIA ADELANTE O HACIA ATRÁS.\n";

init:

cout<<"\tDame el minuendo: ";

cin>>m;

cout<<"\tDame el sustraendo: ";

cin>>n;

if(n>m){

cout<<"\tEl minuendo ha de ser mayor que el sustraendo\n";

goto init;

}

cout<<"\tVamos a restar "<<n<<" de "<<m<<endl;

for(i=n; i<m; i++)

contador++;

cout<<"\tHemos obtenido el resultado: "<<contador<<" \n"<<endl;

return 0;

}

Alcance del tiro parabólico

Este programa sigue en la misma línea del anterior. Se trata de resolver problemas tipo y típicos mediante un programa que espera unos datos numéricos introducidos por teclado. La máquina hace todas las operaciones necesarias y proporciona las ecuaciones adecuadas. Este de hoy es un problema clásico: se trata de determinar el alcance de un disparo parabólico a partir de la velocidad inicial y de la inclinación sobre el suelo. Para resolverlo se descompone la velocidad inicial en dos componentes: la velocidad horizontal y la vertical. Contra esta trabaja la gravedad. De esta forma obtenemos dos ecuaciones para el desplazamiento: sy=vy*t + ½g*t²  y   sx=vx*t, siendo sy y sx los desplazamientos vertical y horizontal. Teniendo en cuenta que g es negativa en el ascenso y que cuando el proyectil llega al suelo sy=0 obtenemos una ecuación de 2º grado que resolvemos para t. Una vez obtenido t resolvemos la segunda ecuación para obtener sx.
Combinando estos cálculos llegamos a la fórmula sintética, que también podemos emplear: 
sx= v²*sin(2a)/g.
En esa fórmula podemos ver dos cosas: que el alcance depende fuertemente de la velocidad inicial y que es máximo para 45º, pues seno(2*45) = seno (90) = 1. También podemos derivar respecto a  'a', sx' = v²/g cos(2a) y ver que para a=pi/4  cos(pi/2)=0, marcando el máximo de la primitiva.
P.D. He añadido una linea al programa para calcular la altura máxima que alcanza el proyectil en su movimiento parabólico. La fórmula es sy=v²*sin²(a)/2*g.
Esta fórmula se puede obtener fácilmente derivando respecto de t  sy=v*sin(a)*t + ½g*t² e igualando a cero. Obtenemos t=2*v*sin(a)/g. Sustituyendo este valor de t en la función sy obtenemos la fórmula.


#include<iostream>
#include<cmath>
#define g 9.81
#define pi 3.14159265
using namespace std;
int main()
{
//Variables
double v,vx,vy; //velocid. inicial, componentes de la velocidad.
double a,sx,t; //ang. inclin.,distancia horiz.,tiempo empleado
cout<<"\n\tCalcular el alcance de un proyectil lanzado con una velocidad \n";
cout<<"\tinicial 'v' y con un angulo de inclinación sobre el suelo 'alfa'.\n"<<endl;
//Entrada de Datos
cout<<"Dame velocidad del disparo (metros/seg): ";cin>>v;
cout<<"Dame ángulo de inclinación (grados): ";cin>>a;
a=a*pi/180; //conversión a radianes
//Fórmulas: componentes de la velocidad
vx=v*cos(a);
vy=v*sin(a);
//Solución de la ecuación de 2º grado: -9.8*t*t/2 + vy*t=0, pues cuando llega al suelo sy=0
t=vy/(g/2);
sx=vx*t;
//También: sx=v*cos(a)*v*sin(a)/(g/2) ==> sx=v²sin(2a)/g
//Resultados
cout<<"El alcance del disparo es: "<<sx<<" ms."<<endl;
cout<<"El tiempo que tarda en alcanzar el objetivo es: "<<t<<" seg."<<endl;
cout<<"La altura máxima que alcanza es: "<<v*v*sin(a)*sin(a)/(2*g)<<" ms."<<endl;
return 0;
}

Las máquinas y los problemas

Una cosa que siempre me atrajo es esta de resolver "problemas tipo". Me explico: Ya que tenemos "máquinas calculadoras" que son los ordenadores - que para eso nacieron fundamentalmente - vamos a dejarle a la máquina hacer todos los cálculos con los datos que le entreguemos y el programa adecuado en cada caso. Los datos pueden ser cualesquiera - eso sí, dentro de un orden - y la máquina se encargará de hacer los cálculos. Esto de hacer los cálculos, me temo yo, pasará en el futuro completamente a su dominio. Pero lo que nunca podrán hacer las máquinas son los planteamientos y la utilización de las fórmulas adecuadas. Eso es lo que nosotros les proporcionamos por medio del programa. Programar debiera ser tan fácil como escribir una carta o redactar un mensaje. Y todo el mundo debiera saber hacerlo. Es lo que apareció con aquellas calculadoras de hace 30 años "programables". Aquello nos parecía una "pasada" y realmente que lo era. Pues ahora lo tenemos mucho más fácil con los lenguajes de programación. Y sin embargo probablemente lo despreciamos porque pretendemos hacer programas más "sofisticados" y huimos de lo trillado. Pues bien, he aquí un ejemplo de lo que pretendo decir. Este es un problema tipo y típico de plano inclinado y aceleraciones. Como este se pueden hacer miles y convendría ejercitarse para llegar a dominar completamente esta forma de proceder. En la segunda pantalla hay un pequeño error: la aceleración debe ser dada en mts/seg².


#include<iostream>
#include<cmath>
using namespace std;
#define pi 3.1415926
#define g 9.81
int main()
{
double s,t,v;
double a,t_v,s_v;
double h,i_p;
//Texto
cout<<"\n\t  Un cuerpo, partiendo del reposo, cae por un \n";
cout<<"\t  plano inclinado con un aceleración uniforme\n";
cout<<"\t  recorriendo 'x' metros en 't' segundos.\n";
cout<<"\t  ¿Cuanto tiempo tardará en adquirir una velo-\n ";
cout<<"\t  cidad 'v' desde que empieza a moverse?"<<endl;
cout<<endl;
//Datos
ini:
cout<<"Dame el espacio recorrido por el cuerpo en su descenso por el plano (m): ";cin>>s;
cout<<"Dame el tiempo empleado en recorrer ese espacio (seg): ";cin>>t;
a=(2*s)/(t*t); //cálculo de la aceleración
if(a>=g) {cout<<"Imposible, hay un error. \n";goto ini;} //no se puede alcanzar la aceleración de la gravedad
cout<<"Dame la velocidad final que debe llegar a alcanzar (m/s): ";cin>>v;
//Otras fórmulas
t_v=v/a; //tiempo para alcanzar velocidad final
s_v=a*t_v*t_v/2; //espacio recorrido
h=a*s_v/g; //altura del plano
i_p=asin(h/s_v); //ángulo de inclinación
//Resultados
cout<<"La aceleración del movimiento es de "<<a<<" m/s. "<<endl;
cout<<"El tiempo que tardará en adquirir esa velocidad es de "<<t_v<<" seg. "<<endl;
cout<<"Para entonces el cuerpo habrá recorrido un espacio de "<<s_v<<" metros"<<endl;
cout<<"Comprobación: La velocidad final al cuadrado ha de ser igual al doble de la\n";
cout<<" aceleración por el espacio recorrido. Efectivamente, velocidad final² = "<<v*v<<endl;
cout<<"Y el doble de la aceleración por el espacio recorrido: "<<2*a*s_v<<endl;
cout<<"La altura desde la que cayó ese cuerpo para adquirir esa velocidad es de "<<h<<" m"<<endl; 
cout<<"Y la inclinación del plano "<<i_p*180/pi<<" grados."<<endl;
return 0;
}

Un ejemplo de programación POO

Este programa lo he tomado del libro de Francisco Javier Ceballos "C++ orientado a objetos". Nos indica un poco cómo funciona esto de la programación orientada a objetos. Es un ejemplo elemental de administración de una cuenta en un banco, por ejemplo. Está ligeramente retocado, porque hay algunas cosas que no entiendo.


#include<iostream>
#include<string>
using namespace std;
class CCuenta
{
//Atributos
private:
string nombre;
string cuenta;
double saldo;
double tipoInteres;
//Métodos
public:
void asignarNombre(string nom){
if(nom.length()==0){ cout << "error: cadena vacía\n"; return;}
nombre=nom;
}
string obtenerNombre(){
return nombre;
}
void asignarCuenta(string cue){
if (cue.length()==0){cout << "Error: cuenta no válida\n";return;}
cuenta = cue;
}
string obtenerCuenta(){
return cuenta;
}
void asignarRemanente(double remanente){
saldo=remanente;
return;
}
double estado(){
return saldo;
}
void ingreso(double cantidad) {
if (cantidad<0){cout<<"Error: cantidad negativa\n";return;}
saldo=saldo+cantidad;
}
void reintegro(double cantidad){
if(saldo - cantidad <0) {cout <<"Error: No dispone de saldo\n";return;}
saldo = saldo - cantidad;
}
void asignarTipoDeInteres(double tipo){
if (tipo<0) {cout <<"Error: Tipo no válido\n";return; }
tipoInteres = tipo;
}
double obtenerIntereses(){
return saldo*tipoInteres/100;
}
};
int main(){
string num,nombre;
double interes, cantidad, salida, remanente;
CCuenta cuenta01; //Asignación de un objeto a la clase CCuenta
cout<<"Déme el nombre del titular de la cuenta: ";getline(cin,nombre);
cuenta01.asignarNombre(nombre);
cout<<"Déme el número de su cuenta: ";cin>>num;
cuenta01.asignarCuenta(num);
cout<<"Déme el remanente de su cuenta: ";cin>>remanente;
cuenta01.asignarRemanente(remanente);
cout<<"¿Cuánto va a ingresar? ";cin>>cantidad;
cuenta01.ingreso(cantidad);
cout<<"¿Cuánto va a sacar?: ";cin>>salida;
cuenta01.reintegro(salida);
cout<<"El titular de la cuenta es el Sr. "<<cuenta01.obtenerNombre()<<endl;
cout<<"Su número de cuenta es "<<cuenta01.obtenerCuenta()<<endl;
cout<<"El estado de su cuenta es "<<cuenta01.estado()<<endl;
cuenta01.asignarTipoDeInteres(2.5);
cout<<"Los intereses que producirán su depósito al 2.5 % son "<<cuenta01.obtenerIntereses()<<endl;
}

He corregido un poco la redacción de mis clases SexagRad, RadSexag y PolarRect para adpatrlas a los usos que veo por ahí. Para hacerlo "bonito" se deben hacer dos secciones, una de "declaración" con su parte public y private y otra de "implementación" donde van las funciones o métodos, mientras que en la primera van más bien las variables y los prototipos. Así que las cosas quedarían así:

fichero sexagra1.h


//Declaración
class SexagRad
{
private:
double radianes;
double grados;
double minutos;
double segundos;
const static double pi=3.1415926;
public:
SexagRad (double, double, double);
double gra2sexa();
};
//Implementación
SexagRad :: SexagRad (double g, double m, double s){
grados=g;
minutos=m;
segundos=s;
}
double SexagRad :: gra2sexa(){
minutos = minutos + segundos/60.0;
grados = grados + minutos/60.0;
radianes = grados*pi/180.0;
return radianes;
}
//Declaración
class RadSexag
{
private:
double radianes;
double grados;
double minutos;
double segundos;
const static double pi=3.1415926;
public:
RadSexag (double);
double rad2gra1();
double rad2gra2();
double rad2gra3();
};
//Implementación
RadSexag :: RadSexag (double r){
radianes=r;
}
double RadSexag :: rad2gra1(){
grados=radianes*180.0/pi;
return floor(grados);
}
double RadSexag :: rad2gra2(){
grados=radianes*180.0/pi;
minutos=(grados-rad2gra1())*60.0;
return floor(minutos);
}
double RadSexag :: rad2gra3(){
grados=radianes*180.0/pi;
minutos=(grados-rad2gra1())*60.0;
segundos = (minutos-rad2gra2())*60.0;
return segundos;
}

Fichero polarrect1.h

//Declaración

class PolarRect

{

private:

double modulo;

double argumento;

public:

PolarRect (double,double);

double primcomp();

double segucomp();

};

// Implementación

PolarRect :: PolarRect (double md, double a){

modulo = md;

argumento = a;

}

double PolarRect :: primcomp(){

return modulo*cos(argumento);

}

double PolarRect :: segucomp(){

return modulo*sin(argumento);

}

Finalmente pongo uno de los ficheros que utilizan esta clase un poco corregido conforme a algunos retoques. Tener en cuenta que a veces los resultados del argumento (ángulo) los da como números negativos. No pasa nada: En vez de 120º, por ejemplo, dará -60º.

#include<iostream>

#include<cmath>

#include "polarrect1.h"

#include "sexagra1.h"

using namespace std;

int main()

{

int c;

cout<<"Cuántos vectores: ";cin>>c;

double md[c],a[c],r;

double g[c],m[c],s[c];

double v[c][2], vr1=0,vr2=0;

for(int i=0;i<c;i++){

cout<<"Dame el módulo del vector: ";cin>>md[i];

cout<<"Dame el argumento del vector: grados, minutos ,segundos: ";cin>>g[i]>>m[i]>>s[i];

SexagRad ang(g[i],m[i],s[i]);

a[i]=ang.gra2sexa();

PolarRect objeto(md[i], a[i]);

v[i][1]=objeto.primcomp();

v[i][2]=objeto.segucomp();

cout<<"La primera componente es "<<v[i][1]<<endl;

cout<<"La segunda componente es "<<v[i][2]<<endl;

}

for (int i=0;i<c;i++){

vr1=vr1+v[i][1];

}

for (int i=0;i<c;i++){

vr2=vr2+v[i][2];

}

r=atan(vr2/vr1);

cout<<"Las componentes de la suma de los vectores son: "<<vr1<<" y "

<<vr2<<endl;

cout<<"El módulo de la resultante es "<<sqrt(vr1*vr1+vr2*vr2)<<endl;

RadSexag angr(r);

cout<<"Su argumento "<<angr.rad2gra1()<<" grados "<<angr.rad2gra2()<<" minutos "<<angr.rad2gra3()<<" segundos"<<endl;

return 0;

}

Sumar cualquier número de vectores (plano)

Este programa es el mismo del otro día solo que algo mejorado puesto que permite sumar cualquier número de vectores. Tengo algunas dudas con los ángulos límite del tipo 180º, 90º, 270º, etc. Creo que es preferible dar los grados solo hasta 180º como positivos y negativos; por ejemplo en vez de 300º,  darle -60º. Solo sirve para vectores en el plano. Para el espacio creo que se podrá ampliar fácilmente.

#include<iostream>
#include<cmath>
#include "polarrect.h"
#include "sexagra.h"
using namespace std;
int main()
{
int c;
cout<<"Cuántos vectores: ";cin>>c;
double md[c],a[c],r;
double g[c],m[c],s[c];
double v[c][2], vr1=0,vr2=0;
for(int i=0;i<c;i++){
cout<<"Dame el módulo del vector: ";cin>>md[i];
cout<<"Dame el argumento del vector: grados, minutos ,segundos: ";cin>>g[i]>>m[i]>>s[i];
SexagRad ang(g[i],m[i],s[i]);
a[i]=ang.gra2sexa();
PolarRect objeto(md[i], a[i]);
v[i][1]=objeto.primcomp();
v[i][2]=objeto.segucomp();
cout<<"La primera componente es "<<v[i][1]<<endl;
cout<<"La segunda componente es "<<v[i][2]<<endl;
}
for (int i=0;i<c;i++){
vr1=vr1+v[i][1];
}
for (int i=0;i<c;i++){
vr2=vr2+v[i][2];
}
r=atan(vr2/vr1);
cout<<"Las componentes de la suma de los vectores son: "<<vr1<<" y "
<<vr2<<endl;
cout<<"El módulo de la resultante es "<<sqrt(vr1*vr1+vr2*vr2)<<endl;
RadSexag1 angr(r);
cout<<"Su argumento "<<angr.rad2gra1()<<" grados "<<angr.rad2gra2()<<" minutos "<<angr.rad2gra3()<<" segundos"<<endl;
return 0;
}

Manejo de vectores (polar, rectangular y suma)

Este programa permite pasar vectores en coordenadas polares a componentes rectangulares, sumarlos y luego presentar el resultado en coordenadas polares de nuevo. Funciona bien por lo menos para vectores con argumentos entre 0º y 90º. La cosa no sería muy allá si no utilizara clases, que eso es lo que para mí es todo un logro. La clase SexagRad y RadSexag1 están en el fichero sexagra.h que ya puse el otro día.  La clase PolarRect en el polarrect.h, que pongo al final de esta entrada. Ojo, por el momento funciona para sumar dos o tres vectores, pero se puede arreglar fácilmente.

#include<iostream>
#include<cmath>
#include<iomanip>
#include "polarrect.h"
#include "sexagra.h"
using namespace std;
int main()
{
int c;
double md[4],a[4],r;
double g[4],m[4],s[4];
double v[4][4], vr[2][2];
cout<<"Cuántos vectores: ";cin>>c;
for(int i=0;i<c;i++){
cout<<"Dame el módulo del vector: ";cin>>md[i];
cout<<"Dame el argumento del vector: grados, minutos ,segundos: ";cin>>g[i]>>m[i]>>s[i];
SexagRad ang(g[i],m[i],s[i]);
a[i]=ang.gra2sexa();
PolarRect objeto(md[i], a[i]);
v[i][1]=objeto.primcomp();
v[i][2]=objeto.segucomp();
cout<<setprecision(8);
cout<<"La primera componente es "<<v[i][1]<<endl;
cout<<"La segunda componente es "<<v[i][2]<<endl;
}
vr[0][1]=v[0][1]+v[1][1]+v[2][1];
vr[0][2]=v[0][2]+v[1][2]+v[2][2];
r=atan(vr[0][2]/vr[0][1]);
cout<<"Las componentes de la suma de los vectores son: "<<vr[0][1]<<" y "
<<vr[0][2]<<endl;
cout<<"El módulo de la resultante es "<<sqrt(vr[0][1]*vr[0][1]+vr[0][2]*vr[0][2])<<endl;
RadSexag1 angr(r);
cout<<"Su argumento "<<angr.rad2gra1()<<" grados "<<angr.rad2gra2()<<" minutos "<<angr.rad2gra3()<<" segundos"<<endl;
return 0;
}

Esta es la clase PolarRect que pasa de polares a rectangulares:


class PolarRect
{
private:
double modulo;
double argumento;
public:
PolarRect (double md, double a){
modulo = md;
argumento = a;
}
double primcomp(){
return modulo*cos(argumento);
}
double segucomp(){
return modulo*sin(argumento);
}
};

Un programa en C++ para pasar grados>radianes y al revés.

Seguimos peleando con esto de las clases dirigidas a objetos. No sé si algunos libros nos lo complican demasiado. Yo lo que he sacado en limpio lo estoy explotando para hacer programas que resuelvan problemas como cálculos geométricos o físicos. Este es un ejemplo. Sirve para pasar grados, minuto, segundos a radianes, y al revés.


#include<iostream>
#include<cmath>
#include "sexagra.h"
using namespace std;
int main(){
int opcion;
double g,m,s,r;
double rads;
double grados, minutos, segundos;
cout<<"1. Grados->Radianes"<<endl;
cout<<"2. Radianes ->Grados"<<endl;
cout<<"Pulsa 1 o 2"<<endl;
cin>>opcion;
if(opcion==1) {
cout<<"Dame los grados: ";cin>>g;
cout<<"Dame los minutos: ";cin>>m;
cout<<"Dame los segundos: ";cin>>s;
SexagRad ang(g,m,s);
rads=ang.gra2sexa();
cout<<"El ángulo en radianes vale "<<rads<<endl;
}
else {
cout<<"Dame el ángulo en radianes: "; cin>>r;
RadSexag1 ang1(r);
grados=ang1.rad2gra1();
minutos=ang1.rad2gra2();
segundos=ang1.rad2gra3();
cout<<r<<" radianes son "<<grados<<" grados y ";
cout<<minutos<<" minutos y ";
cout<<segundos<<" segundos"<<endl;
}
return 0;
}

Y este es el programa que contiene las dos clases.


class SexagRad
{
private:
double radianes;
double grados;
double minutos;
double segundos;
const static double pi=3.1415926;
public:
SexagRad (double g, double m, double s){
grados=g;
minutos=m;
segundos=s;
}
double gra2sexa(){
minutos = minutos + segundos/60;
grados = grados + minutos/60;
radianes = grados*pi/180;
return radianes;
}
};
class RadSexag1
{
private:
double radianes;
double grados;
double minutos;
double segundos;
const static double pi=3.1415926;
public:
RadSexag1 (double r){
radianes=r;
}
double rad2gra1(){
grados=radianes*180/pi;
return floor(grados);
}
double rad2gra2(){
grados=radianes*180/pi;
minutos=(grados-rad2gra1())*60;
return floor(minutos);
}
double rad2gra3(){
grados=radianes*180/pi;
minutos=(grados-rad2gra1())*60;
segundos = (minutos-rad2gra2())*60;
return floor(segundos);
}
};
Si a alguno le sirve, estupendo.

Programas en C++

Puesto que hacer programas en C y en C++ es una de mis diversiones favoritas voy a dedicar este blog, elcantodelmirlo2, a poner mis programitas, que van señalando también mis progresos y comprensión del lenguaje. Empecemos hoy con el último alumbramiento. En él empleo clases, que además manejan tres variables. Se trata de calcular el peso de un cilindro en función del radio, la altura y la densidad. Son dos programas, uno el principal y otro la clase. Ha funcionado.
Programa principal. Se llama clases33.cpp:


#include<iostream>
#include "cili.h"
using namespace std;
int main()
{
double r, h, ro;
cout<<"Dame el radio de la base (mts.): ";cin>>r;
cout<<"Dame la altura (mts.): ";cin>>h;
cout<<"Dame la densidad (gr/cm3): ";cin>>ro;
Cilindro unObjeto(r,h,ro);
double arealat = unObjeto.arealCilindro();
double areatotal = unObjeto.areatCilindro();
double volumen = unObjeto.volCilindro();
double peso = unObjeto.pesoCilindro();
cout<<"El área lateral del cilindro es "<<arealat<<" mets2"<<endl;
cout<<"El área total del cilindro es "<<areatotal<<" mts2"<<endl;
cout<<"El volumen del cilindro es "<<volumen<<" mts3"<<endl;
cout<<"El peso del cilindro es "<<peso<<" newtons o "<<peso/9.81<<" kilopondios"<<endl;
return 0;
}

Y éste es la clase, se llama cili.h:

//Esta clase calcula el peso de un cilindro en función de tres variables, radio, altura y densidad. Emplea dos constantes.
class Cilindro
{
private:
double radio;
double altura;
double densidad;
const static double pi=3.1415926;
const static double g=9.81;
public:
Cilindro (double r, double h, double ro){
radio=r;
altura=h;
densidad=ro;
}
double areabCilindro(){
double areabase = pi*radio*radio;
return areabase;
}
double volCilindro(){
double volumen = areabCilindro()*altura;
return volumen;
}
double arealCilindro(){
double area = 2*pi*radio*altura;
return area;
}
double areatCilindro(){
double areatot = arealCilindro()+2*areabCilindro();
return areatot;
}
  double pesoCilindro(){
double peso = 1000*densidad*g*volCilindro();
return peso;
}
};