caly ten tekst chyba sie nie zmiesci ale mozesz mu dac screeny


polecenie:

Kolokwium
27/01/2026
Dla struktury danych
struct DATA_POINT {
	double pressure;
	double temperature;
};
utworzyć aplikację, która dynamicznie przydziela pamięć dla tablic struktur DATA_POINT, wypełnia te tablice strukturami o losowych składowych, zapisuje tablice do pliku binarnego oraz odczytuje tablice z plików binarnych. W programie powinny znaleźć się następujące funkcje:
struct DATA_POINT *CreateArray(size_t dim)
	/*###############################################
	Dynamicznie alokuje pamięć dla tablicy elementów
	typu DATA_POINT o rozmiarze dim i zwraca wskaźnik
	do tej tablicy
	#################################################*/
struct DATA_POINT * FreeArray(struct DATA_POINT *tab)
/*###############################################
Zwalnia pamięć dla tablicy tab
#################################################*/
void FillArray(struct DATA_POINT *tab)
/*###########################################
Wypełnia macierz tab losowymi wartościami tak, że
składowe pressure struktur DATA_POINT należą do
przedziału [0, 1000], a składowe temperature
do przedziału [0, 100]
#############################################*/
void PrintArray(struct DATA_POINT *tab)
/*######################################
Wyświetla zawartość tablicy tab, tzn. tabelę
z kolumną "Cisnienie" i kolumną "Temperatura",
w których znajdują się odpowiednie składowe
struktur DATA_POINT z tej tablicy
########################################*/
void MyExit(FILE *pft, struct DATA_POINT *tab)
/*#############################################
Zamyka otwarte pliki, dealokuje pamięć i kończy
działanie programu z kodem 1.
###############################################*/
void Save(struct DATA_POINT * tab, char *filename)
/*##########################################################
Zapisuje dane z tablicy tab elementów typu DATA_POINT do pliku
o nazwie filename. Używa zapisu w trybie binarnym. Na samym
początku pliku ma znaleźć się liczba typu (unsigned int),
która jest liczbą elementów zapisywanej tablicy struktur. Następnie
zapisywane są dane dotyczące kolejnych elementów tablicy (od
elementu 0 do ostatniego).
Funkcja sprawdza czy:
- plik został poprawnie otworzony,
- zapis, którejkolwiek z zapisywanych danych przebiegł prawidłowo,
jeżeli nie, program jest niezwłocznie zamykany (wraz z dealokacją
pamięci, zamykaniem otwartych plików, etc.).
Po zakończeniu zapisu plik należy zamknąć.
############################################################*/
struct DATA_POINT * Read(struct DATA_POINT * tab, char *filename)
/*###########################################################
Odczytuje dane z pliku binarnego filename w ten sposób, aby
utworzyć z tych danych tablicę struktur DATA_POINT. Działanie tej
funkcji ma być odwrotne do Save() - tzn. chcemy odzyskać taką samą
tablicę, jak została zapisana do pliku. Argument tab jest wskaźnikiem
do tak skonstruowanej tablicy oraz wielkością zwracaną przez funkcję.
Program ma być zamknięty, jeżeli: plik nie został poprawnie otwarty,
pojawił się błąd przy którymkolwiek odczycie danych z pliku lub
wystąpi błąd alokacji pamięci.
#############################################################*/
Funkcja main() powinna:
000. Przyjmować od użytkownika ze strumienia stdin rozmiar tablicy struktur
00.	Zaalokować pamięć dla pierwszej tablicy struktur DATA_POINT, wypełnić składowe struktur losowymi liczbami i wyświetlić tą tablicę.
0.	Zapisać tą tablicę do pliku MyFile.bin.
1.	Wypełniać na nowo pierwszą tablicę
2.	Ponownie wyświetlać jej elementy na ekran
3.	Odczytać zawartość pliku MyFile.bin tak, aby utworzyć z tych danych nową tablicę
4.	Wyświetlać drugą tablicę (oczekujemy wyniku identycznego z pierwszym "printem", a różnego od drugiego)
5.	Zwalniać pamięć i zwracać kod 0 na koniec
Zadanie wykonać w dwóch plikach:
•	kolokwium.c – głównym pliku źródłowym
•	stdafx.h – pliku nagłówkowym zawierającym definicję struktury oraz prototypy funkcji

Skorzystać z plików Kolokwium.txt oraz stdafx.txt stanowiących szablon projektu.
W plikach szablonowych brakuje definicji trzech funkcji oraz części funkcji main() (łącznie 4 „TO DO”) – uzupełnić te braki.





kolokwium.c:
#include "stdlib.h"
#include "time.h"
#include "stdafx.h"

int main()
{
	char FileName[] = "MyFile.bin";		//nazwa pliku binarnego do zapisu
	size_t dim;							//rozmiar tablicy
	printf("Podaj rozmiar tablicy = ");
	scanf_s("%zu", &dim);
	//tworzymy, wypełniamy i wyświetlamy pierwotną tablicę tab elementów DATA_POINT
	struct DATA_POINT* tab = CreateArray(dim);
	FillArray(tab);
	printf("Tablica tab\n");
	printf("------------------------------------\n");
	PrintArray(tab);
	Save(tab, FileName);//zapisujemy tą tablicę
	system("pause");

	/*############################################
	W tej części funkcji main()
	1. Wypełniamy na nowo tablicę tab
	2. Wyświetlamy jej elementy na ekran
	3. Odczytujemy zawartość pliku MyFile.bin tak,
	aby utworzyć z tych danych nową tablicę tab_new
	4. Wyświetlamy tablicę tab_new (oczekujemy wyniku
	identycznego z pierwszym "printem", a różnego od
	drugiego)
	5. Zwalniamy pamięć i zwracamy kod 0 na koniec
	##############################################*/

	// TO DO

}

struct DATA_POINT* CreateArray(size_t dim)
	/*###############################################
	Dynamicznie alokuje pamięć dla tablicy elementów
	typu DATA_POINT o rozmiarze dim i zwraca wskaźnik
	do tej tablicy
	#################################################*/
{
	// TO DO
}

struct DATA_POINT* FreeArray(struct DATA_POINT* tab)
	/*###############################################
	Zwalnia pamięć dla tablicy tab
	#################################################*/
{
	if (tab)
	{
		free(tab);
		tab = NULL;
	}
	return NULL;
}

void FillArray(struct DATA_POINT* tab)
/*###########################################
Wypełnia macierz tab losowymi wartościami tak, że
składowe pressure struktur DATA_POINT należą do
przedziału [0, 1000], a składowe temperature
do przedziału [0, 100]
#############################################*/
{
	size_t it, dim = _msize(tab) / sizeof(struct DATA_POINT);
	srand((unsigned int)time(NULL));

	for (it = 0; it < dim; ++it) {
		tab[it].pressure = rand() * 1000 / (double)RAND_MAX;
		tab[it].temperature = rand() * 100 / (double)RAND_MAX;
	}
}

void PrintArray(struct DATA_POINT* tab)
/*######################################
Wyświetla zawartość tablicy tab, tzn. tabelę
z kolumną "Cisnienie" i kolumną "Temperatura",
w których znajdują się odpowiednie składowe
struktur DATA_POINT z tej tablicy
########################################*/
{
	size_t it, dim = _msize(tab) / sizeof(struct DATA_POINT);

	printf("%-20s%-20s\n", "Cisnienie [hPa]", "Temperatura [C]");
	for (it = 0; it < dim; ++it) {
		printf("%-20lf   %-20lf\n", tab[it].pressure, tab[it].temperature);
	}
	printf("\n");
}

void MyExit(FILE* pft, struct DATA_POINT* tab)
/*#############################################
Zamyka otwarte pliki, dealokuje pamięć i kończy
działanie programu z kodem 1.
###############################################*/
{
	if (pft)
		fclose(pft);

	FreeArray(tab);
	printf("fatal error\n");
	exit(1);
}

void Save(struct DATA_POINT* tab, char* filename)
/*##########################################################
Zapisuje dane z tablicy tab elementów typu DATA_POINT do pliku
o nazwie filename. Używa zapisu w trybie binarnym. Na samym
początku pliku ma znaleźć się liczba typu (unsigned int),
która jest liczbą elementów zapisywanej tablicy struktur. Następnie
zapisywane są dane dotyczące kolejnych elementów tablicy (od
elementu 0 do ostatniego).
Funkcja sprawdza czy:
- plik został poprawnie otworzony,
- zapis, wszystkich z zapisywanych danych przebiegł prawidłowo,
jeżeli nie, program jest niezwłocznie zamykany (wraz z dealokacją
pamięci, zamykaniem otwartych plików, etc.).
Po zakończeniu zapisu plik należy zamknąć.
############################################################*/
{
	//TO DO
}

struct DATA_POINT* Read(struct DATA_POINT* tab, char* filename)
	/*###########################################################
	Odczytuje dane z pliku binarnego filename w ten sposób, aby
	utworzyć z tych danych tablicę struktur DATA_POINT. Działanie tej
	funkcji ma być odwrotne do Save() - tzn. chcemy odzyskać taką samą
	tablicę, jak została zapisana do pliku. Argument tab jest wskaźnikiem
	do tak skonstruowanej tablicy oraz wielkością zwracaną przez funkcję.
	Program ma być zamknięty, jeżeli: plik nie został poprawnie otwarty,
	pojawił się błąd przy którymkolwiek odczycie danych z pliku lub
	wystąpi błąd alokacji pamięci.
	#############################################################*/
{
	//TO DO
}

stdafx.h:
#pragma once
#pragma once
#pragma warning (disable : 4996)

#include 
#include 

struct DATA_POINT { //punkt pomiarowy dla gazu badanego w eksperymencie
	double pressure;	//cisnienie
	double temperature;	//temperatura
};

struct DATA_POINT* CreateArray(size_t dim);
struct DATA_POINT* FreeArray(struct DATA_POINT* tab);
void FillArray(struct DATA_POINT* tab);
void PrintArray(struct DATA_POINT* tab);
void MyExit(FILE* pft, struct DATA_POINT* tab);
void Save(struct DATA_POINT* tab, char* filename);
struct DATA_POINT* Read(struct DATA_POINT* tab, char* filename);





koniec :))




---

### 1. Plik nagłówkowy `stdafx.h`

Zgodnie z poleceniem, plik ten zawiera definicję struktury `DATA_POINT` oraz prototypy wszystkich wymaganych funkcji .

```c
#pragma once
#pragma warning (disable : 4996)
#include 
#include 
#include 
#include  // Wymagane dla funkcji _msize

struct DATA_POINT {
    double pressure;    [cite_start]// cisnienie [cite: 212]
    double temperature; [cite_start]// temperatura [cite: 213]
};

[cite_start]// Prototypy funkcji [cite: 215-221]
struct DATA_POINT* CreateArray(size_t dim);
struct DATA_POINT* FreeArray(struct DATA_POINT* tab);
void FillArray(struct DATA_POINT* tab);
void PrintArray(struct DATA_POINT* tab);
void MyExit(FILE* pft, struct DATA_POINT* tab);
void Save(struct DATA_POINT* tab, char* filename);
struct DATA_POINT* Read(struct DATA_POINT* tab, char* filename);

```

---

### 2. Plik źródłowy `kolokwium.c`

Poniżej znajduje się kod z uzupełnionymi brakującymi elementami (funkcje `CreateArray`, `Save`, `Read` oraz brakująca logika w `main`).

```c
#include "stdafx.h"

int main()
{
    char FileName[] = "MyFile.bin"; [cite_start]// nazwa pliku binarnego do zapisu [cite: 85]
    size_t dim; [cite_start]// rozmiar tablicy [cite: 86]

    printf("Podaj rozmiar tablicy = ");
    scanf_s("%zu", &dim); [cite_start]// [cite: 88]

    [cite_start]// Tworzymy, wypełniamy i wyświetlamy pierwotną tablicę [cite: 89-94]
    struct DATA_POINT* tab = CreateArray(dim);
    FillArray(tab);
    printf("Tablica tab\n");
    printf("------------------------------------\n");
    PrintArray(tab);

    Save(tab, FileName); [cite_start]// zapisujemy tą tablicę [cite: 95]
    system("pause");

    /* ############################################
       [cite_start]TO DO: Realizacja punktów 1-5 w main() [cite: 98-108]
    ############################################## */
    
    [cite_start]// 1. Wypełniamy na nowo tablicę tab [cite: 99]
    FillArray(tab);

    [cite_start]// 2. Wyświetlamy jej elementy na ekran [cite: 100]
    printf("Tablica tab po ponownym wypelnieniu (powinna byc inna):\n");
    PrintArray(tab);

    [cite_start]// 3. Odczytujemy zawartość pliku MyFile.bin do nowej tablicy [cite: 101-102]
    struct DATA_POINT* tab_new = NULL;
    tab_new = Read(tab_new, FileName);

    [cite_start]// 4. Wyświetlamy tablicę tab_new (oczekujemy wyniku jak przy pierwszym princie) [cite: 103-105]
    printf("Tablica tab_new odczytana z pliku (powinna byc identyczna z pierwsza):\n");
    PrintArray(tab_new);

    [cite_start]// 5. Zwalniamy pamięć i zwracamy kod 0 [cite: 106]
    FreeArray(tab);
    FreeArray(tab_new);

    return 0;
}

[cite_start]// TO DO: Implementacja CreateArray [cite: 110-118]
struct DATA_POINT* CreateArray(size_t dim) 
{
    struct DATA_POINT* tab = (struct DATA_POINT*)malloc(dim * sizeof(struct DATA_POINT));
    if (tab == NULL) {
        MyExit(NULL, NULL); [cite_start]// Wyjście w przypadku błędu alokacji [cite: 63]
    }
    return tab;
}

[cite_start]// Funkcja FreeArray [cite: 119-130]
struct DATA_POINT* FreeArray(struct DATA_POINT* tab) 
{
    if (tab) {
        free(tab);
        tab = NULL;
    }
    return NULL;
}

[cite_start]// Funkcja FillArray [cite: 131-145]
void FillArray(struct DATA_POINT* tab) 
{
    size_t it, dim = _msize(tab) / sizeof(struct DATA_POINT);
    srand((unsigned int)time(NULL));
    for (it = 0; it < dim; ++it) {
        tab[it].pressure = rand() * 1000.0 / (double)RAND_MAX; [cite_start]// Przedział [0, 1000] [cite: 23-24]
        tab[it].temperature = rand() * 100.0 / (double)RAND_MAX; [cite_start]// Przedział [0, 100] [cite: 24-25]
    }
}

[cite_start]// Funkcja PrintArray [cite: 146-160]
void PrintArray(struct DATA_POINT* tab) 
{
    size_t it, dim = _msize(tab) / sizeof(struct DATA_POINT);
    printf("%-20s%-20s\n", "Cisnienie [hPa]", "Temperatura [C]");
    for (it = 0; it < dim; ++it) {
        printf("%-20lf %-20lf\n", tab[it].pressure, tab[it].temperature);
    }
    printf("\n");
}

[cite_start]// Funkcja MyExit [cite: 161-172]
void MyExit(FILE* pft, struct DATA_POINT* tab) 
{
    if (pft) fclose(pft);
    if (tab) FreeArray(tab);
    printf("fatal error\n");
    exit(1);
}

[cite_start]// TO DO: Implementacja Save [cite: 173-190]
void Save(struct DATA_POINT* tab, char* filename) 
{
    FILE* f = fopen(filename, "wb"); [cite_start]// Tryb binarny [cite: 42]
    if (!f) MyExit(NULL, tab); [cite_start]// Błąd otwarcia [cite: 48]

    size_t dim = _msize(tab) / sizeof(struct DATA_POINT);
    unsigned int u_dim = (unsigned int)dim;

    [cite_start]// Zapis liczby elementów [cite: 43-44]
    if (fwrite(&u_dim, sizeof(unsigned int), 1, f) != 1) MyExit(f, tab);

    [cite_start]// Zapis danych struktury [cite: 45-46]
    if (fwrite(tab, sizeof(struct DATA_POINT), dim, f) != dim) MyExit(f, tab);

    fclose(f); [cite_start]// [cite: 52]
}

[cite_start]// TO DO: Implementacja Read [cite: 191-204]
struct DATA_POINT* Read(struct DATA_POINT* tab, char* filename) 
{
    FILE* f = fopen(filename, "rb");
    if (!f) MyExit(NULL, tab); [cite_start]// Błąd otwarcia [cite: 61]

    unsigned int u_dim;
    [cite_start]// Odczyt liczby elementów [cite: 58]
    if (fread(&u_dim, sizeof(unsigned int), 1, f) != 1) MyExit(f, tab);

    [cite_start]// Alokacja nowej tablicy [cite: 57, 63]
    struct DATA_POINT* tab_new = CreateArray((size_t)u_dim);

    [cite_start]// Odczyt danych do nowej tablicy [cite: 62]
    if (fread(tab_new, sizeof(struct DATA_POINT), u_dim, f) != u_dim) {
        MyExit(f, tab_new);
    }

    fclose(f);
    return tab_new; [cite_start]// Zwraca wskaźnik do nowej tablicy [cite: 60]
}

```

---

### Kluczowe uwagi do implementacji:

* 
**Zarządzanie pamięcią:** Do określenia rozmiaru tablicy wewnątrz funkcji `FillArray` i `PrintArray` wykorzystano funkcję `_msize` , co sugeruje środowisko MSVC (Visual Studio), zgodnie z użyciem `scanf_s`.


* 
**Obsługa błędów:** Funkcje `Save` i `Read` każdorazowo sprawdzają poprawność operacji na plikach oraz alokacji, wywołując `MyExit` w razie niepowodzenia .


* 
**Format zapisu:** Plik binarny zaczyna się od nagłówka typu `unsigned int` określającego liczbę struktur , po którym następują dane binarne.



koniec



















#include "stdafx.h"
#include "stdio.h"
#include "stdlib.h"
#include "windows.h"


struct MY_CAR
{
	int year;
	char nazwa[64];
};

size_t pozycja = 0;
MY_CAR* pStruct = NULL;

int fun_create_array(int dim)
{
	if (!pStruct)
	{
		pStruct = (MY_CAR *)malloc(dim * sizeof(MY_CAR));

		if (!pStruct)
			return 0;

		memset((void *)pStruct, 0, dim * sizeof(MY_CAR));
		pozycja = 0;
		return 1;
	}
	return 0;
}



void fun_print_tab(char *title)
{
	size_t ob_poz;

	printf("%s\n\n", title);

	for (ob_poz = 0; ob_poz < pozycja; ++ob_poz)
	{
		printf("\nElement %zu: \n", ob_poz + 1);
		printf("Nazwa: %s\n", pStruct[ob_poz].nazwa);
		
		printf("Rok: %d\n\n", pStruct[ob_poz].year);
	}
}



void fun_free()
{
	if (pStruct)
	{
		free(pStruct);
		pStruct = NULL;
		pozycja = 0;
		printf("\nPamiec zwolniona \n");
	}

}



void fun_fill_array(int dim)
{
	for (int i = 0; i < dim; ++i)
	{
		if (pozycja < dim) {
			printf("Element %d: \n", i);
			printf("Podaj nazwe (max 63 znaki): ");
			scanf_s("%s", pStruct[pozycja].nazwa, (unsigned)_countof(pStruct[pozycja].nazwa));

			printf("Podaj rok: ");
			if (scanf_s("%d", &pStruct[pozycja].year) != 1)
			{
				printf("blad wczytywania roku");
				break;
			}
			pozycja++;
		}
	}


}



int main()
{
	int dim;
	printf("podaj ilosc elementow");
	if (scanf_s("%d", &dim) != 1 || dim <= 0)
	{
		return 1;
	}

	if (fun_create_array(dim))
	{
		fun_fill_array(dim);
		fun_print_tab("wynikowe dane");
		fun_free();
	}
	else {
		printf("blad alokacji pamieci lub tablica juz istniala");
	}
	system("pause");

	return 0;

}