Sprawdzenie czy ktoś jest pełnoletni

#include <iostream>
using namespace std;

int main()
{
    int dzien, miesiac, rok, wynik;
    int b_dzien, b_miesiac, b_rok;

    
    cout<<"Podaj biezaca date"<<endl;
    cout<<"Dzien: ";
    cin>>b_dzien;
    cout<<"Miesiac: ";
    cin>>b_miesiac;
    cout<<"Rok: ";
    cin>>b_rok;
    cout<<"Podaj date urodzin "<<endl;
    cout<<"Dzien: ";
    cin>>dzien;
    cout<<"Miesiac: ";
    cin>>miesiac;
    cout<<"Rok: ";
    cin>>rok;
        if (rok <=2002) cout << "jestes pelnoletni" << endl;
        else cout << "jestes niepelnoletni" << endl;
        if (rok >2002) cout << "bedziesz pelnoletni za " ;
        cout << " ";
        

        
system ("pause");
return 0;
}

#include <iostream>
using namespace std;
int dzienUrodzenia, miesiacUrodzenia, rokUrodzenia, dzienObecny, miesiacObecny, rokObecny, roznica;
int main()
{
    cout<<"Witaj w programie ktory pobiera date urodzenia oraz date terazniejsza i sprawdza czy osoba jest pelnoletnia"<<endl;
    cout<<"Podaj dzien, miesiac i rok urodzenia dowolnej osoby: "<<endl;
    cin>>dzienUrodzenia;
    if(dzienUrodzenia>31||dzienUrodzenia<1)
    {
        cout<<"Wprowadzony dzien urodzenia jest nieprawidlowy"<<endl; 
        return 0;
    }
    cin>>miesiacUrodzenia;
    if(miesiacUrodzenia>12||miesiacUrodzenia<1)
    {
        cout<<"Wprowadzony miesiac urodzenia jest nieprawidlowy"<<endl; 
        return 0;
    }
    cin>>rokUrodzenia;
    cout<<"Podaj aktualny dzien, miesiac i rok: "<<endl;
    cin>>dzienObecny;
    if(dzienObecny>31||dzienObecny<1)
    {
        cout<<"Wprowadzony obecny dzien jest nieprawidlowy"<<endl; 
        return 0;
    }
    cin>>miesiacObecny;
    if(miesiacObecny>12||miesiacObecny<1)
    {
        cout<<"Wprowadzony obecny miesiac jest nieprawidlowy"<<endl; 
        return 0;
    }
    cin>>rokObecny;
    cout<<endl;
    roznica=rokObecny-rokUrodzenia;
    if(roznica>18)
    {
        cout<<"Osoba jest pelnoletnia"<<endl;
    }
    if(roznica==18)
    {
        if(miesiacUrodzenia<miesiacObecny)
        {
            cout<<"Osoba jest pelnoletnia"<<endl;
        }
        if(miesiacUrodzenia>miesiacObecny)
        {
            cout<<"Osoba jest niepelnoletnia"<<endl;
        }
        if(miesiacUrodzenia==miesiacObecny)
        {
            if(dzienUrodzenia<dzienObecny)
            {
                cout<<"Osoba jest pelnoletnia"<<endl;
            }
            if(dzienUrodzenia>dzienObecny)
            {
                cout<<"Osoba jest niepelnoletnia"<<endl;
            }
            if(dzienUrodzenia==dzienObecny)
            {
                cout<<"Osoba jest pelnoletnia"<<endl;
            }
        }
    }
    return 0;
}

#include <iostream>
#include <ctime>
#include <limits>

// Function to calculate age based on birth year, month, and day
int calculateAge(int birthYear, int birthMonth, int birthDay) {
    // Get the current date
    std::time_t t = std::time(nullptr);
    std::tm* now = std::localtime(&t);
    int currentYear = now->tm_year + 1900;
    int currentMonth = now->tm_mon + 1; // Month is 0-based, so add 1
    int currentDay = now->tm_mday;

    // Calculate the age
    int age = currentYear - birthYear;

    // Check birth month and day
    if (currentMonth < birthMonth || (currentMonth == birthMonth && currentDay < birthDay)) {
        age--;
    }

    return age;
}

// Function to check if a year is a leap year
bool isLeapYear(int year) {
    return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}

// Function to validate the day for a given month and year
bool isValidDay(int day, int month, int year) {
    if (day < 1 || day > 31) {
        return false; // Day is out of valid range
    }

    if (month == 4 || month == 6 || month == 9 || month == 11) {
        return day <= 30; // April, June, September, November have 30 days
    } else if (month == 2) {
        return (isLeapYear(year) && day <= 29) || (!isLeapYear(year) && day <= 28); // February
    } else {
        return true; // All other months have 31 days
    }
}

int main() {
    int birthYear, birthMonth, birthDay;

    // Input validation for birth year
    do {
        std::cout << "Enter your birth year: ";
        if (!(std::cin >> birthYear)) {
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            std::cout << "Invalid input. Please enter a valid year." << std::endl;
        }
    } while (birthYear <= 0);

    // Input validation for birth month
    do {
        std::cout << "Enter your birth month (1-12): ";
        if (!(std::cin >> birthMonth) || birthMonth < 1 || birthMonth > 12) {
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            std::cout << "Invalid input. Please enter a valid month (1-12)." << std::endl;
        }
    } while (birthMonth < 1 || birthMonth > 12);

    // Input validation for birth day
    do {
        std::cout << "Enter your birth day: ";
        if (!(std::cin >> birthDay) || !isValidDay(birthDay, birthMonth, birthYear)) {
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            std::cout << "Invalid input. Please enter a valid day." << std::endl;
        }
    } while (!isValidDay(birthDay, birthMonth, birthYear));

    // Calculate the age using the function
    int age = calculateAge(birthYear, birthMonth, birthDay);

    // Check if the person has reached the age of majority
    int ageOfMajority = 18;

    if (age >= ageOfMajority) {
        std::cout << "You have reached the age of majority." << std::endl;
    } else {
        int monthsLeft = (ageOfMajority - age) * 12;
        std::cout << "You have not reached the age of majority yet." << std::endl;
        std::cout << "You have " << monthsLeft << " months left to reach the age of majority." << std::endl;
    }

    return 0;
}

#include <chrono>
#include <ctime>
#include <iostream>

int main()
{
    using clock = std::chrono::system_clock;
    std::tm birthDate {};
    while (std::cin >> std::get_time(&birthDate, "%Y-%m-%d")) {
        auto adultDate = birthDate;
        adultDate.tm_year += 18;
        auto adultTime = clock::from_time_t(std::mktime(&adultDate));
        auto now = clock::now();
        if (adultTime > now) {
            auto roundDiff = ceil<std::chrono::days>(adultTime - now);
            std::cout << "You are to young by: " << roundDiff << '\n';
        } else {
            std::cout << "You are old enogh\n";
        }
    }

    return 0;
}

#include <iostream>
#include <chrono>
#include <variant>
#include <ctime>
#include <cassert>

enum class AgeGroup { ADULT, ADOLESCENT };
enum class InvalidDate { INVALID_BIRTH_DATE, INVALID_CURRENT_REFERENCE_DATE };

using BirthDate = const std::tm&;
using CurrentDate = const std::tm&;
using AgeGroupOrError = std::variant<AgeGroup, InvalidDate>;

const double hoursInDay = 24.0;
const double daysInYear = 365.25;  // Average considering leap years

std::tm createDate(int year, int month, int day) {
    std::tm date = {0};
    date.tm_year = year - 1900; // Year since 1900
    date.tm_mon = month - 1;    // Month [0-11]
    date.tm_mday = day;         // Day [1-31]
    return date;
}

bool isValidDate(const std::tm& date) {
    std::tm temp_date = date;
    return std::mktime(&temp_date) != -1 &&
           temp_date.tm_year == date.tm_year &&
           temp_date.tm_mon == date.tm_mon &&
           temp_date.tm_mday == date.tm_mday;
}

AgeGroupOrError isAdult(BirthDate birthDate, CurrentDate currentDate, int adultAge = 18) {
    if (!isValidDate(birthDate)) {
        return InvalidDate::INVALID_BIRTH_DATE;
    }
    if (!isValidDate(currentDate)) {
        return InvalidDate::INVALID_CURRENT_REFERENCE_DATE;
    }

    auto birth_time = std::mktime(const_cast<std::tm*>(&birthDate));
    auto current_time = std::mktime(const_cast<std::tm*>(&currentDate));
    auto duration = std::chrono::system_clock::from_time_t(current_time) - std::chrono::system_clock::from_time_t(birth_time);
    auto years = std::chrono::duration_cast<std::chrono::hours>(duration).count() / (daysInYear * hoursInDay);

    return years >= adultAge ? AgeGroup::ADULT : AgeGroup::ADOLESCENT;
}