Establecer diferencia en días de 2 fechas distintas [C].

[rdv316]

Hola gente.
Tal vez les resulte un tanto extraño encontrar un post con un programa que compila correctamente y la lógica parece correcta, digo esto porque lo terminé hace una hora y por las pruebas que hice funciona correctamente.-
El motivo principal es para que me enseñen a modular este código en lenguaje C, no parecería algo difícil pero no me animo a hacerlo sólo la primera vez porque si logro que funcione seguramente no entenderé la lógica, siempre pudiendo hacer preguntas a los expertos me resulta más intuitivo, además en los blog por ej. casi nunca el autor te asiste.-
Por último y si tienen mucho tiempo y ganas me gustaría que me den alguna idea para mejorarlo.-

Código C:

// Programa para establecer la diferencia en día(s) entre 2 fechas diferentes.
 
#include <stdio.h>
 
typedef struct{
    int dia;
    int mes;
    int anio;
}Fecha;
 
int regularBisiesto( Fecha fecha1 ); //A0001
 
 
int main(void){
    Fecha fecha1 = { 15, 04, 2015 }, fecha2 = { 28, 04, 2015 }; //A0002
    int difAnios, difDias=0, i, regBisAnioF1 = 0, regBisAnioF2; 
    int tot_dias[] = { 00,31,28,31,30,31,30,31,31,30,31,30,31 };
    
    difAnios = fecha2.anio - fecha1.anio; //A0003
    regBisAnioF1 = regularBisiesto(fecha1); //A0004             
    
    if( difAnios == 0){ //A0005
        if( fecha1.mes == fecha2.mes ){ //A0006
            difDias += fecha2.dia - fecha1.dia;
        }
        else{ //A0007
            difDias += (tot_dias[fecha1.mes] - fecha1.dia); 
            if( fecha1.mes == 2 ){
                difDias += regBisAnioF1;
            }       
            for( i=fecha1.mes+1; i < fecha2.mes; i++){
                if( i == 2 ){
                    difDias += regBisAnioF1; 
                }   
                difDias += tot_dias[i];                 
            }
            difDias += fecha2.dia;
        }   
    }
    else{ //A0008
        difDias += (tot_dias[fecha1.mes] - fecha1.dia); //B0008
        if(fecha1.mes == 2){
            difDias += regBisAnioF1;
        }       
        if( fecha1.mes < 12 ){
            for( i = fecha1.mes +1; i <= 12; i++ ){
                difDias += tot_dias[i]; 
            }
        }
        for( i=fecha1.anio +1; i < fecha2.anio -1; i++){ // A0009
            difDias += 365;
            regBisAnioF1 = regularBisiesto(fecha1);
            difDias += regBisAnioF1;
        }
        regBisAnioF2 = regularBisiesto(fecha2);
        for( i=1; i < fecha2.mes; i++ ){ //A0010
            if( i == 2 ){
                difDias += regBisAnioF2; 
            }   
            difDias += tot_dias[i];
        }
        difDias += fecha2.dia; //A0011
    }
 
    printf("\n Diferencia en dias....: %d", difDias);
    
    getchar();
    return 0;
}
 
int regularBisiesto( Fecha fechaRb ){ //A0001
    if ((fechaRb.anio %4 == 0 && fechaRb.anio%100 != 0) || (fechaRb.anio%400) == 0){
        return 1;
    }
    else{
        return 0;
    }
}
 
/*
================================ Ayuda ================================
    A0001..: Función para establecer si el año es bisiesto.-
    A0002..: Fechas a consultar.-
    A0003..: se guarda en difAnios la diferencia en años de las 2 fechas.- 
    A0004..: Se verifica si el año (fecha1) es bisiesto.-
    A0005..: Se ejecuta lo que está dentro del cuerpo del if solamente si las 2 fechas tienen el mismo año.-
    A0006..: Si son iguales los años y los meses de las 2 fechas solo queda  restar fecha1.dia - fecha2.dia.-
    A0007..: Si los meses son distintos, en primer lugar se busca en tot_dias los dias que tiene el correspondiente
                mes de fecha1 y se los resta a fecha1.dia, después si el mes es Febrero se suma 1 si el año es
                bisiesto, luego los meses siguiente si los hay se busca en tot_dias y se los suma completos
                en este caso no se debe incluir fecha1.mes ni fecha2.mes (sólo los intermedios), al salir del bucle
                for queda tan sólo sumar los días que tenga fecha2.dia.-    
    A0008..: En caso que los años sean distintos, en primer lugar hay que establecer los días que faltan para llegar
                a fin de mes ej. 15/02/2000 para el comienzo del próximo mes (Marzo) faltarían 13 días pero como
                el año 2000 fué bisiesto, se le debe agregar 1 dia. Luego se les debe sumar todos los meses
                completos hasta llegar a Diciembre, esta validación es para verificar que fecha1.mes no sea
                Diciembre, de ser así ya está contemplado en B0008, con esto se completa del inicio de fecha1
                hasta el 31/12 del mismo año.-  
    A0009..: El bucle se ejecuta si entre las 2 fechas hay más de 1 año, por ej. 15/03/2012 al 19/04/2015, en este
             caso 2013 y 2014 se suman completos, 365 días si no es bisiesto y 366 si lo es.-
    A0010..: Este bucle establece los días que transcurrieron desde el 01/01/fecha2.anio a fecha2.mes-1.-                   
    A0011..: Y lo último es sumar los días que hay desde el 01/fecha2.mes al fecha2.dia.- 
*/
 

Desde ya muchas grcias por el tiempo que le dediquen.-
Daniel

EDITO: Seguramente pensaran para que hacer un programa de 103 líneas si con unas pocas y utilizando la biblioteca de c se logra lo mismo y seguramente más eficiente, lo que sucede es que este tipo de código me da una gran ejercitación mental más que nada con lo que respecta a la programación que estoy un poco flojo, he cometido el error de muchos, creo que primero deberíamos estudiar programación y luego hacer los programas con el lenguaje que mejor se adapte al mismo (aprender la sintaxis de los lenguajes es lo de menos).-

[lareto]

Hola. No me puse a analizar el código, pero igual me atrevo a señalarte alguna cosa que me llamó la atención.

Al escribir

28, 04, 2015

, para el compilador todo número precedido por un 0 está expresado en base 8 (octal), con lo que no podrás escribir 08 ni 09, naturalmente.

Hice una prueba con diez años de diferencia:
fecha1 = { 10, 12, 2010 };
fecha2 = { 10, 12, 2020 };
con lo que esperaba algo parecido a 3650 días, pero el programa calcula 3286, así que es seguro que algo no anda del todo bien.

Me parecía que en una respuesta anterior alguien había sugerido la conveniencias de expresar las fecha en días o en segundos con respecto a alguna fecha de referencia (el sistema Unix, por ejemplo, adoptó los segundos a partir del 1 de enero de 1970 para expresar las fechas) . No creo que sea obligatorio ni irrespetuoso no hacer lo mismo, pero reducir todo a la misma unidad antes de hacer los cálculos solía ser un recurso práctico razonable cuando resolvíamos problemas en la escuela, y no parecía mala idea.

Bueno, eso nada más; espero que mis comentarios tengan algún sentido y te resulten útiles, al menos mientras esperamos la respuesta de algún experto.

[eferion]

Tu programa tiene varios errores:

Código C:

int regularBisiesto( Fecha fechaRb ){ //A0001
    if ((fechaRb.anio %4 == 0 && fechaRb.anio%100 != 0) || (fechaRb.anio%400) == 0){
        return 1;
    }
    else{
        return 0;
    }
}
 

En la función anterior, únicamente haces uso del campo "anio". En este caso es preferible modificar la función para que únicamente acepte un entero. ¿motivo? Pues porque te obliga a hacer cosas raras:

Código C:

for( i=fecha1.anio +1; i < fecha2.anio -1; i++){ // A0009
            difDias += 365;
            regBisAnioF1 = regularBisiesto(fecha1);
            difDias += regBisAnioF1;
        }
 

Si te fijas, en el intervalo fecha1.anio < i < fecha2.anio compruebas llamas todo el rato a regularBisiesto pasando "fecha1"... fecha que, dicho sea de paso, no cambia... esto quiere decir que si fecha1 es inicialmente bisiesto estarás asumiendo que todos los años intermedios son bisiestos y, si fecha1 no es bisiesto, ignorará todos los años bisiestos que se encuentren en el intervalo.

Además, ahí estás eliminando un año. Prueba a poner dos fechas separadas exactamente por dos años. p.ej: 1/1/2001 y 1/1/2003. Verás que el programa te dice que la diferencia es de 365 días.

Código C:

regBisAnioF2 = regularBisiesto(fecha2);
        for( i=1; i < fecha2.mes; i++ ){ //A0010
            if( i == 2 ){
                difDias += regBisAnioF2;
            }  
            difDias += tot_dias[i];
        }
 

En este caso... ¿qué pasa si fecha2 = 01/02/2004? pues que asume que el 2004 es bisiesto y le suma el día correspondiente al 29 de febrero.

También tienes código innecesario. Por ejemplo:

Código C:

if( fecha1.mes < 12 ){
            for( i = fecha1.mes +1; i <= 12; i++ ){
                difDias += tot_dias[i];
            }
        }
 

Ese if es innecesario. ¿por qué? facil. Si el mes es 12, al ejecutarse el bucle no se cumplirá i = mes + 1 <= 12 <=> i = 13 <= 12, por lo que el bucle no se ejecutará en ningún momento. Eliminar código innecesario mejora enormemente la legibilidad del código (y de paso eliminas cosas que no necesitas)

Y con eso más o menos entiendo que debería estar. Eso sí, deberías acostumbrarte a usar un depurador de código. Con eso y con un cuadernito con el que hacer las cuentas a mano a ver si cuadran deberías ser capaz de localizar todos estos problemas :)

Y bueno, hablando también del diseño general del código tengo malas noticias. Repites demasiado código en proporción con el tamaño final del programa. Creo que deberías intentar eliminar el código redundante en la medida de lo posible

[rdv316]

Hola a todos.
lareto, gracias por participar y ya tengo en cuenta lo del cero, el código que expongo a continuación contempla tu consulta y da como resultado 3653  365 x 10 = 3650, incluye 3 años bisiestos 2012/2016/2020.-
eferion, gracias pero muchas gracias, desconozco cuanto tiempo tardaría en hacer que funcione correctamente sin tu ayuda.-

Y bueno, hablando también del diseño general del código tengo malas noticias. Repites demasiado código en proporción con el tamaño final del programa. Creo que deberías intentar eliminar el código redundante en la medida de lo posible

Me podrías ayudar con esto, no encuentro como reducir el código, para mi todas las líneas son necesarias.-

Daniel

[rdv316]

Código:

// Programa para establecer la diferencia en día(s) entre 2 fechas diferentes.

#include <stdio.h>

typedef struct{
	int dia;
	int mes;
	int anio;
}Fecha;

int regularBisiesto( int tFecha );


int main(void){
	Fecha fecha1 = { 10,12, 2010 }, fecha2 = { 10,12, 2020 };
	int difAnios, difDias=0, i, regBisAnioF1 = 0, regBisAnioF2, tFecha1, tFecha2; 
	tFecha1 = fecha1.anio;
	tFecha2 = fecha2.anio;
	int tot_dias[] = { 00,31,28,31,30,31,30,31,31,30,31,30,31 };
	
	difAnios = fecha2.anio - fecha1.anio;
	regBisAnioF1 = regularBisiesto(tFecha1);				
	
	if( difAnios == 0){
		if( fecha1.mes == fecha2.mes ){
			difDias += fecha2.dia - fecha1.dia;
		}
		else{
			difDias += (tot_dias[fecha1.mes] - fecha1.dia); 
			if( fecha1.mes == 2 ){
				difDias += regBisAnioF1;
			}		
			for( i=fecha1.mes+1; i < fecha2.mes; i++){
				if( i == 2 ){
					difDias += regBisAnioF1; 
				}	
				difDias += tot_dias[i]; 				
			}
			difDias += fecha2.dia;
		}	
	}
	else{
		difDias += (tot_dias[fecha1.mes] - fecha1.dia);
		if(fecha1.mes == 2){
			difDias += regBisAnioF1;
		}		
		for( i = fecha1.mes +1; i <= 12; i++ ){
			difDias += tot_dias[i]; 
		}
		for( i=tFecha1 + 1; i < fecha2.anio ; i++){
			tFecha1++;
			difDias += 365;
			regBisAnioF1 = regularBisiesto(tFecha1);
			difDias += regBisAnioF1;
		}
		regBisAnioF2 = regularBisiesto(tFecha2);
		for( i=1; i < fecha2.mes; i++ ){
			if( i == 2 ){
				difDias += regBisAnioF2; 
			}	
			difDias += tot_dias[i];
		}
		difDias += fecha2.dia;
	}

	printf("\n Del %d/%d/%d al %d/%d/%d hay %d dias", fecha1.dia, fecha1.mes, fecha1.anio,
			fecha2.dia, fecha2.mes, fecha2.anio, difDias);
	
	getchar();
	return 0;
}

int regularBisiesto( int tFecha ){
	if ((tFecha %4 == 0 && tFecha%100 != 0) || (tFecha%400) == 0){
		return 1;
	}
	else{
		return 0;
	}
}

[eferion]

Iniciado por rdv316

Me podrías ayudar con esto, no encuentro como reducir el código, para mi todas las líneas son necesarias.

Te intento contestar mañana... que ya es tarde y mañana hay que madrugar :)

-----

Iniciado por rdv316

Me podrías ayudar con esto, no encuentro como reducir el código, para mi todas las líneas son necesarias.

Te intento contestar mañana... que ya es tarde y mañana hay que madrugar :)

-----

Variables que se pueden eliminar

Los resultados temporales únicamente interesa almacenarlos en variables si:

• El resultado se reutiliza varias veces dentro de un bucle (sobretodo si la operación es costosa)
• Estamos en fase de desarrollo y facilita las tareas de depuración

Fuera de estos contextos es mejor evitar el uso de variables temporales. Tener una función con multitud de variables es como tener el escritorio lleno de cosas, al final cuesta encontrar la información que necesitamos.

En tu caso puedes llegar a eliminar el 30% de las variables del main:

• regBisAnioF1 y regBisAnioF2 se pueden sustituir directamente por la llamada a la función:
  
  Antes:
  
  Código c:

  regBisAnioF1 = regularBisiesto(tFecha1);
  difDias += regBisAnioF1;
   

  
  Despues:
  
  Código c:

  difDias += regularBisiesto(tFecha1);
   

• difAnios puede correr la misma suerte con toda tranquilidad:
  
  Antes:
  
  Código c:

  difAnios = fecha2.anio - fecha1.anio;
  if( difAnios == 0){
   

  
  Despues:
  
  Código c:

  if( (fecha2.anio - fecha1.anio) == 0 ){
   

Refactorización del código

1. Cuando realizas una comparación ( >, <, >=, <=, ==, != ) puedes obtener dos resultados posibles: 1 (TRUE) o 0 (FALSE)

Si miras el código de regularBisiesto verás que esta función está devolviendo 1 para TRUE y 0 para FALSE. Si eliminas el if y pasas a retornar el resultado de la comparación conseguirás el mismo resultado y todo en una única línea:

Código c:

int regularBisiesto( int anio ){
    return ((anio %4 == 0 && anio%100 != 0) || (anio%400) == 0);
}
 

Por cierto, llamar tFecha al argumento de regularBisiesto no parece buena idea. Los nombres de las variables tienen que dar una idea acerca de lo que almacenan y de la utilidad que se le pretende dar. tFecha da a entender que estás almacenando una fecha, cuando realmente está almacenando el valor del año.

2. Cuando estás trabajando con fechas de diferentes años haces uso de un bucle que itera sobre los años intermedios para calcular el número de días de este intervalo. En cada iteración sumas 365 días más la corrección por bisiesto cuando procede. Este bucle te lo puedes ahorrar si tienes en cuenta un par de consideraciones:

• Todos los años tienen, al menos 365 días
• Puedes saber la cantidad de bisiestos que hay entre dos fechas con una sencilla operación matemática

Dicho con código:

Antes:

Código c:

for( i=tFecha1 + 1; i < fecha2.anio ; i++)
{
  tFecha1++;
  difDias += 365;
  difDias += regularBisiesto(tFecha1);
}
 

Despues:

Código c:

difDias += (fecha2.anio - fecha1.anio - 1) * 365;
difDias += (fecha2.anio-1) / 4 - (fecha2.anio-1) / 100 + (fecha2.anio-1) / 400;
difDias -= (fecha1.anio / 4) - (fecha1.anio / 100) + (fecha1.anio / 400);
 

Explicación del código:

• La primera línea coge el número de años completos entre las dos fechas y lo multiplica por 365
• En la segunda se calcula el número de años bisiestos hasta la fecha final (año no incluído).
• En la tercera se calcula el número de años bisiestos hasta la fecha inicial.
• Si se restan los dos últimos cálculos se obtiene el número de bisiestos en el rango dado.

Al quitarte un bucle consigues, aunque en este caso no se note, que el tiempo de ejecución sea el mismo, independientemente del número de años que haya entre las dos fechas. El código propuesto es algo más lento que el que tenías si las dos fechas están bastante próximas, pero según se van distanciando las fechas tu código va siendo cada vez más lento, mientras que el mío se mantiene estable.

Por supuesto lo puedes dejar "más bonito" si mueves el cálculo a una función:

Código c:

difDias += (fecha2.anio - fecha1.anio - 1) * 365;
difDias += numeroBisiestos(fecha2.anio-1) - numeroBisiestos(fecha1.anio);
 
//...
 
int numeroBisiestos( int anio )
{
  return anio / 4 - anio / 100 + anio / 400;
}
 

3. ¿Y si en vez de un array con los días de cada mes devolvemos el día del año?

A veces, cambiar la perspectiva nos ayuda a encontrar soluciones más sencillas a nuestros problemas. En tu caso estás haciendo distincción entre dos posibles casos:

• Las fechas son del mismo año
• Las fechas son de años diferentes

Conseguir un algoritmo que sea capaz de trabajar indistintamente con ambos casos te evita tener código duplicado y, como has comentado, dificil de refactorizar. Vamos a intentar acabar con la duplicidad.

Lo primero que vamos a cambiar es, como indica el título, calcular el día del año. Esto se puede conseguir reutilizando parte de tu código:

Código c:

int diaDelAnio( Fecha fecha )
{
  int tot_dias[] = { 00,31,28,31,30,31,30,31,31,30,31,30,31 };
 
  int dias = fecha.dia;
  int mes;
  
  for( mes = 1; mes < fecha.mes; ++mes )
    dias += tot_dias[mes];
 
  if( fecha.mes > 2 )
    dias += regularBisiesto( fecha.anio );
 
  return dias;
}
 

Con esta sencilla función podemos obrar milagros dentro de tu código. Como verás, ahora ya ha desaparecido el if y todo el código duplicado:

Código c:

#include <stdio.h>
 
typedef struct{
    int dia;
    int mes;
    int anio;
}Fecha;
 
int regularBisiesto( int tFecha );
int numeroBisiestos( int anio );
int diaDelAnio( Fecha fecha );
 
// Algoritmo para calcular el número de días entre dos fechas
// Los cálculos realizados son:
// Si las fechas son del mismo año se calcula el intervalo:
//   - fecha1 -> fecha2
// Si las fechas son de diferentes años se calculan 3 intervalos:
//   - fecha1 -> fin año fecha1
//   - días por los años intermedios
//   - inicio año fecha2 -> fecha2
int main(void){
  Fecha fecha1 = { 1,1, 2050 }, fecha2 = { 12,12, 2050 };
  int difDias = 0;
 
  // Cálculo del intervalo fecha1 -> fecha2
  // no se tienen en cuenta los años en este punto porque la corrección se realiza después
  difDias = diaDelAnio( fecha2 ) - diaDelAnio( fecha1 );
 
  if( fecha1.anio != fecha2.anio )
  {
    // Días por los años completos
    difDias += (fecha2.anio - fecha1.anio - 1) * 365;
    difDias += numeroBisiestos(fecha2.anio - 1) - numeroBisiestos(fecha1.anio);
 
    // Cálculo correspondiente al intervalo fecha1 -> fin año fecha1
    fecha1.dia = 31;
    fecha1.mes = 12;
    difDias += diaDelAnio( fecha1 );
  }
 
  printf("\n Del %d/%d/%d al %d/%d/%d hay %d dias", fecha1.dia, fecha1.mes, fecha1.anio,
            fecha2.dia, fecha2.mes, fecha2.anio, difDias);
 
  getchar();
  return 0;
}
 
int regularBisiesto( int anio)
{
  return ((anio%4 == 0 && anio%100 != 0) || (anio%400) == 0);
}
 
int numeroBisiestos( int anio )
{
  return anio / 4 - anio / 100 + anio / 400;
}
 
int diaDelAnio( Fecha fecha )
{
  int tot_dias[] = { 00,31,28,31,30,31,30,31,31,30,31,30,31 };
 
  int dias = fecha.dia;
  int mes;
 
  for( mes = 1; mes < fecha.mes; ++mes )
    dias += tot_dias[mes];
 
  if( fecha.mes > 2 )
    dias += regularBisiesto( fecha.anio );
 
  return dias;
}
 

¿Te gusta la nueva versión? Es bastante corta, es legible y utiliza muy poquitas variables :)

Un saludo

[rdv316]

Hola eferion.
Cuantas reflexiones me mueve este post, la primera es que la sintaxis se puede leer, estudiar, picar código y sale, en cuanto a las correcciones que hiciste sobre mi código en la calle se llama utilizar criterio, sentido común esto en un gran porcentaje se trae en cada reencarnación y de lo contrario se obtiene pensando mucho pero mucho cuando uno está construyendo el pseudocódigo del programa, esto puede ser en papel o en la mente.-
Concluyendo, muchas gracias por tu tiempo y por tanta y tan buena exposición/explicación, estoy leyendo y releyendo tú post y ya he encontrado un par de cosas muy importante y como buen capricorniano (testarudo) voy a intentar una nueva versión, si la logro con menos de 64 líneas (la cantidad de líneas que ocupa el tuyo) lo subo.-
Amigo muchas gracias por tú tiempo y espero encontrarte siempre con mis dudas y que no sean programas completos sino sólo desconocimiento de sintaxis.-

Daniel.

[rdv316]

Hola gente.
He creado una versión un poco más reducida y la dejo a continuación, espero que siempre de resultados correctos, hice muchas pruebas y todo bien.-
Eferion, estoy temblando por las modificaciones que puedas sugerirme, (chiste) espero esas sugerencias.-

http://www.calendario-365.es/calcula...os-fechas.html

Código C:

#include <stdio.h>
 
typedef struct{
    int dia;
    int mes;
    int anio;
}Fecha;
 
int numeroBisiestos( int anio );
 
int main(void){
    int totalDiasAnio[] = {00,31,59,90,120,151,181,212,243,273,304,334,365};
    int totalDias=0, difAnio=0, i;
    Fecha F1 = {4,5,2015} , F2 = {4,5,2025};
    
    difAnio = F2.anio - F1.anio;
    
    if( difAnio == 0){
        totalDias += (totalDiasAnio[F2.mes-1] + F2.dia) - (totalDiasAnio[F1.mes-1] + F1.dia);   
        if( F1.mes <= 2 && F2.mes > 2) {totalDias += numeroBisiestos(F1.anio);}
    }
    else{
        totalDias += 365 - (totalDiasAnio[F1.mes-1] + F1.dia);
        if( F1.mes < 3) {totalDias += numeroBisiestos(F1.anio);}
        
        for( i= F1.anio +1; i< F2.anio; i++ ){
            totalDias += 365 + numeroBisiestos(i);
        }
        
        totalDias += totalDiasAnio[F2.mes-1] + F2.dia;
        if( F2.mes > 2) {totalDias += numeroBisiestos(F2.anio);}
    }
    printf("\n Del %d/%d/%d al %d/%d/%d hay %d dias", F1.dia, F1.mes, F1.anio,
            F2.dia, F2.mes, F2.anio, totalDias);
    getchar();
    return 0;
}
 
int numeroBisiestos( int anio ){
    if((anio %4 == 0 && anio%100 != 0) || (anio%400) == 0){return 1;}
    else{return 0;}
}
 

Daniel

[paez903]

Yo se que el post es un poco viejo pero no consigo uno mas nuevo pero necesito una ayuda de los expertos a ver si pueden ayudar, estoy calculando entre dos fechas, pero una vez hecho esto me dice cuantos dias tengo entre las dos fechas, hasta alli todo bien.
Pero ahora una vez me dice cuantos dias existen entre las dos le coloco una condicional que dice:

días entre las fechas si es menor o igual a 5 años me muestre 30
si es menor o igual a 10 años me muestre 33
si es menor o igual a 15 años me muestre 36 y asi sucesivamente hasta 25 años, esto con el fin de tomar posterior la fecha2 y le sume estos dias es decir por ejemplo 01/01/2000 a esto se le suma 30 dias y resultado seria 01/02/2000, pero no consigo hacerlo. paso el codigo a ver si me pueden ayudar.
<?php


$dia='12';
$mes='8';
$año='2005';



$fechaingreso=mktime(0,0,0,"$dia","$mes","$año");
$fecha2=mktime(0,0,0,"08","10","2009");

$diferencia=$fecha2-$fechaingreso;
$dias=$diferencia/(60*60*24);



if ($dias<=1825) {

echo "30";

}
else
{
if ($dias<=3650) {
echo "33";
}
else
{
if ($dias<=5475) {

echo "39";
}
else
{
if ($dias<=7300) {
echo "39";
}
}
}
}
?>

[vangodp]

Si es C seria algo como esto:

Código C:

if (dias<=1825) {
    //echo "30";
 
}else if (dias<=3650) {
    //echo "33";
 
}else if (dias<=5475) {
    //echo "39";
 
}else if (dias<=7300) {
    //echo "39";
}