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.