Podstawowe Funkcje w języku C

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h> 
#include <math.h>

#define MAKS_PROBEK 10000 


void pobierzWspolczynniki(double wspolczynniki[4])
{
    printf("Podaj wspolczynnik A: ");
    scanf("%lf", &wspolczynniki[0]);
    printf("Podaj wspolczynnik B: ");
    scanf("%lf", &wspolczynniki[1]);
    printf("Podaj wspolczynnik C: ");
    scanf("%lf", &wspolczynniki[2]);
    printf("Podaj wspolczynnik D: ");
    scanf("%lf", &wspolczynniki[3]);
}

void pobierzDziedzine(double* xmin, double* xmax)
{
    printf("Podaj dolna granice dziedziny (xmin): ");
    scanf("%lf", xmin);
    printf("Podaj gorna granice dziedziny (xmax): ");
    scanf("%lf", xmax);
}

int pobierzLiczbeProbek()
{
    int liczbaProbek;
    printf("Podaj liczbe probek: ");
    scanf("%d", &liczbaProbek);

    if (liczbaProbek < 1 || liczbaProbek > MAKS_PROBEK) {
        printf("Niepoprawna liczba probek. Ustawiono domyslna wartosc: 300.\n");
        return 300;
    }
    return liczbaProbek;
}

void generujSygnal(double wspolczynniki[4], double xmin, double xmax, double* sygnal, int liczbaProbek)
{
    double A = wspolczynniki[0];
    double B = wspolczynniki[1];
    double C = wspolczynniki[2];
    double D = wspolczynniki[3];

    double krok = (xmax - xmin) / (double)(liczbaProbek - 1);

    for (int i = 0; i < liczbaProbek; i++)
    {
        double x = xmin + i * krok; 
        sygnal[i] = A * sin((x + C) / B) + D; 
    }
}

void wypiszSygnal(double* sygnal, int liczbaProbek)
{
    printf("Wygenerowany sygnal:\n");
    for (int i = 0; i < liczbaProbek; i++)
    {
        printf("%d: %lf\n", i, sygnal[i]);
    }
}

int main() {
    double wspolczynniki[4];
    double xmin, xmax;    

    pobierzWspolczynniki(wspolczynniki); 
    pobierzDziedzine(&xmin, &xmax); 
    int liczbaProbek = pobierzLiczbeProbek(); 

    double* sygnal = (double*)malloc(liczbaProbek * sizeof(double));
    if (sygnal == NULL) {
        printf("Blad alokacji pamieci.\n");
        return 1; 
    }
    generujSygnal(wspolczynniki, xmin, xmax, sygnal, liczbaProbek); 
    wypiszSygnal(sygnal, liczbaProbek); 
    free(sygnal);

    return 0;
}
-------------------------------------------------
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_NAZWA 100

// Struktura przechowująca obraz PGM
typedef struct {
    char nazwa[MAX_NAZWA];
    char format[3]; // P2 lub P5
    int szerokosc;
    int wysokosc;
    int max_szary;
    unsigned char** piksele;
} ObrazPGM;

// Funkcja do pomijania komentarzy w pliku PGM
void pomin_komentarze(FILE* plik) {
    int znak;
    while ((znak = fgetc(plik)) == '#') {
        while ((znak = fgetc(plik)) != '\n' && znak != EOF);
    }
    ungetc(znak, plik);
}

// Funkcja do odczytu obrazu PGM z pliku
ObrazPGM* wczytajPGM(const char* nazwaPliku) {
    FILE* plik = fopen(nazwaPliku, "r");
    if (!plik) {
        perror("Nie mozna otworzyc pliku");
        return NULL;
    }

    ObrazPGM* obraz = (ObrazPGM*)malloc(sizeof(ObrazPGM));
    strcpy(obraz->nazwa, nazwaPliku);

    fscanf(plik, "%2s", obraz->format);
    pomin_komentarze(plik);
    fscanf(plik, "%d %d", &obraz->szerokosc, &obraz->wysokosc);
    pomin_komentarze(plik);
    fscanf(plik, "%d", &obraz->max_szary);
    fgetc(plik); // Pomijamy znak nowej linii

    // Alokacja pamięci dla pikseli
    obraz->piksele = (unsigned char**)malloc(obraz->wysokosc * sizeof(unsigned char*));
    for (int i = 0; i < obraz->wysokosc; i++)
        obraz->piksele[i] = (unsigned char*)malloc(obraz->szerokosc * sizeof(unsigned char));

    // Wczytywanie pikseli
    for (int i = 0; i < obraz->wysokosc; i++)
        for (int j = 0; j < obraz->szerokosc; j++)
            fscanf(plik, "%hhu", &obraz->piksele[i][j]);

    fclose(plik);
    printf("Obraz %s wczytany poprawnie.\n", nazwaPliku);
    return obraz;
}

// Funkcja do zapisu obrazu PGM do pliku
void zapiszPGM(const ObrazPGM* obraz, const char* nazwaPliku) {
    FILE* plik = fopen(nazwaPliku, "w");
    if (!plik) {
        perror("Nie mozna zapisac pliku");
        return;
    }

    fprintf(plik, "%s\n", obraz->format);
    fprintf(plik, "%d %d\n", obraz->szerokosc, obraz->wysokosc);
    fprintf(plik, "%d\n", obraz->max_szary);

    for (int i = 0; i < obraz->wysokosc; i++) {
        for (int j = 0; j < obraz->szerokosc; j++) {
            fprintf(plik, "%d ", obraz->piksele[i][j]);
        }
        fprintf(plik, "\n");
    }

    fclose(plik);
    printf("Obraz zapisany jako %s.\n", nazwaPliku);
}

// Funkcja zwalniająca pamięć obrazu
void zwolnijObraz(ObrazPGM* obraz) {
    for (int i = 0; i < obraz->wysokosc; i++)
        free(obraz->piksele[i]);
    free(obraz->piksele);
    free(obraz);
}



// Funkcja główna
int main() 
{
    ObrazPGM* obraz = NULL;
    int wybor;
    char nazwaPliku[MAX_NAZWA];

    do {
        printf("\nMENU:\n");
        printf("1. Wczytaj obraz PGM\n");
        printf("2. Zapisz obraz PGM\n");
        printf("3. Wyjdz\n");
        printf("Wybierz opcje: ");
        scanf("%d", &wybor);

        switch (wybor) {
        case 1:
            if (obraz) zwolnijObraz(obraz);
            printf("Podaj nazwe pliku do odczytu: ");
            scanf("%s", nazwaPliku);
            obraz = wczytajPGM(nazwaPliku);
            break;

        case 2:
            if (!obraz) {
                printf("Najpierw wczytaj obraz.\n");
                break;
            }
            printf("Podaj nazwe pliku do zapisu: ");
            scanf("%s", nazwaPliku);
            zapiszPGM(obraz, nazwaPliku);
            break;

        case 3:
            if (obraz) zwolnijObraz(obraz);
            printf("Zamykanie programu...\n");
            break;

        default:
            printf("Nieprawidlowy wybor, sprobuj ponownie.\n");
        }
    } while (wybor != 3);
    return 0;
}
-------------------------------------------

struct kontakt
{
    char imie[50];
    char nazwisko[50];
    char numer[50];
    char grupa[50];
};

struct element 
{
    struct element* poprzedni;
    struct kontakt dane;
    struct element* nastepny;
};

void dodajNaKoniec(struct element** poczatek, struct element** koniec, struct kontakt dane)
{
    struct element* nowy = (struct element*)malloc(sizeof(struct element));
    if (!nowy) 
    {
        printf("Blad alokacji pamieci\n");
        return;
    }
    nowy->dane = dane;
    nowy->nastepny = NULL;
    nowy->poprzedni = *koniec;

    if (*koniec) 
    {
        (*koniec)->nastepny = nowy;
    }
    else
    {
        *poczatek = nowy;
    }
    *koniec = nowy;
}
void wczytajPlik(const char* nazwaPliku, struct element** poczatek, struct element** koniec) 
{
    if (!nazwaPliku || !poczatek || !koniec)
    {
        printf("Nieprawidlowe parametry\n");
        return;
    }
    FILE* plik = fopen(nazwaPliku, "r");
    if (!plik) 
    {
        printf("Nie mozna otworzyc pliku\n");
        return;
    }
    char wiersz[256];

    while (fgets(wiersz, sizeof(wiersz), plik)) 
    {

        struct kontakt nowyKontakt;
        if (sscanf(wiersz, "%49[^;];%49[^;];%49[^;];%49[^;]", nowyKontakt.imie, nowyKontakt.nazwisko, nowyKontakt.numer, nowyKontakt.grupa) != 4) 
        {
            printf("Nieprawidlowy format wiersza\n", wiersz);
            continue;
        }
        dodajNaKoniec(poczatek, koniec, nowyKontakt);
    }

    fclose(plik);
    printf("Wczytano liste kontaktow\n");
}

void wyswietlListe(struct element* poczatek) 
{
    if (!poczatek)
    {
        printf("Lista jest pusta\n");
        return;
    }
    struct element* aktualny = poczatek;
    while (aktualny)
    {
        printf("%s %s, Numer: %s, Grupa: %s\n",
            aktualny->dane.imie,
            aktualny->dane.nazwisko,
            aktualny->dane.numer,
            aktualny->dane.grupa);
        aktualny = aktualny->nastepny;
    }
}

void wyczyscListe(struct element** poczatek, struct element** koniec) 
{
    struct element* aktualny = *poczatek;
    while (aktualny)
    {
        struct element* doUsuniecia = aktualny;
        aktualny = aktualny->nastepny;
        free(doUsuniecia);
    }
    *poczatek = NULL;
    *koniec = NULL;
}