Sic Parvis Magna

30 Ağustos 2024 Cuma

C/CPP - Fonksiyonlar ve Kullanım Yöntemleri #7

Ağustos 30, 2024 Posted by unexpected , , No comments

malloc

Her hangi bir veri tipinde yer ayırma işlemi yapar. Ayrıca içeriği boş bir değer atanır. Başarılı ise atanan değişkende yer ayırma işlemi gerçekleşir. Başarısız ise NULL olarak dönüş yapar.

Syntax
void* malloc(size_t size)

Params

  • size: Ayrılacak alan boyutu
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	char* buffer;
	int i = 22;
	
	buffer = (char*)malloc(i + 1);
	if(buffer == NULL) return -1;
	
	for(int n = 0; n < i; n++)
		buffer[n] = n + 1 * 'a';
	buffer[i] = '\0';
	
	printf("Random String: %s", buffer);
	free(buffer);
	
	return 0;
}

realloc

Her hangi bir veri tipinde yer ayırma işlemi yapıldıktan sonra yeniden boyutlandırma yapılması için kullanılır. Başarılı ise atanan değişkende yeniden boyutlandırma işlemi gerçekleşir. Başarısız ise NULL olarak dönüş yapar.

Syntax
void* realloc(void* memory, size_t size);

Params

  • memory: Daha önce ayrılmış bellek
  • size: Yeniden boyutlanacak miktar.
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	float* ptr;
	float* new_ptr;
	
	ptr = (float*)malloc(5 * sizeof(float));
	if(ptr == NULL) return -1;
	
	for(int i = 0; i < 5; i++)
		ptr[i] = i * 1.5;
	
	new_ptr = (float*)realloc(ptr, 10 * sizeof(float));
	if(new_ptr == NULL) return -1;
	
	for(int i = 0; i < 10; i++)
		new_ptr[i] = i * 2.5;
	
	for(int i = 0; i < 5; i++)
		printf("%f ", ptr[i]);
	
	printf("\n");
	
	for(int i = 0; i < 10; i++)
		printf("%f ", new_ptr[i]);
	
	return 0;
}

calloc

Array veri tipin de bir yer ayırma işlemi yapar. Ayrıca içerisini sıfır ile doldurur. Başarız durumunda NULL olarak döner.

Syntax
void* calloc(size_t num, size_t size);

Params

  • num: Oluşturulucak element sayısı
  • size: Veri tipi boyutu
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	int* ptr;
	
	ptr = (int*)calloc(22, sizeof(int));
	for(int i = 0; i < 22; i++)
		printf("%d ", ptr[i]);
	free(ptr);
	
	return 0;
}

free

realloc, calloc ve malloc ile oluşturulan bellekleri serbest bırakır.

Syntax
void free(void* memory);

Params

  • memory: Daha önce ayrılmış bellek

C/CPP - Fonksiyonlar ve Kullanım Yöntemleri #6

Ağustos 30, 2024 Posted by unexpected , , No comments

fopen

Dosya başarıyla açılırsa FILE* nesnesi döner. Açılamaz ise FILE* null olarak döner.

Syntax
FILE* fopen(const char* file, const char* mode);

Params

  • file: Dosya adı
  • mode: Mod
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	FILE* fptr;
	fptr = fopen("01.txt", "r");
	fclose(fptr);
	
	return 0;
}
Mod Description
r read: Dosya okuma modu. Dosya mevcut olmalıdır.
w write: Yeni bir dosya oluştur. Aynı isimde bir dosya var ise üzerine yazar.
a append: Dosyanın içeriğinin sonundan yazmaya devam eder. Dosya yok ise yeniden oluşturur.
t Dosyanın içeriğinin text olduğunu belirtir.
b Dosyanın içeriğinin binary olduğunu belirtir.
r+ read/update: Dosya okuma modu. Dosya mevcut olmalıdır.
w+ write/update: Yeni bir dosya oluştur. Aynı isimde bir dosya var ise üzerine yazar.
a+ append/update: Dosyanın içeriğinin sonundan yazmaya devam eder. Dosya yok ise yeniden oluşturur.

fclose

Açılan dosya ile tüm ilişkileri keser. Başarıyla kapatılır ise 0 değerini döner.

Syntax
int fclose(FILE* file);

Params

  • file: file pointer
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	FILE* fptr;
	fptr = fopen("01.txt", "r");
	fclose(fptr);
	
	return 0;
}

feof

Açılmış bir dosya içeriğinde dosya sonuna geldiğinde 1 gelmediğinde 0 değerini döner.

Syntax
int feof(FILE* file);

Params

  • file: file pointer
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	FILE* fptr;
	fptr = fopen("01.txt", "r");
	
	int out = feof(fptr);
	printf("Return: %d", out);
	
	fclose(fptr);
	
	return 0;
}

fseek

İmlec konumunu ayarlar. Başarı durmunda 0 döner. Başarısız durumunda -1 döner.

Syntax
int fseek(FILE* file, long offset, int origin);

Params

  • file: file pointer
  • offset: Imlec positon
  • origin: Imlec konumu
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	/// SEEK_SET: Dosya başlangıcı
	/// SEEK_CUR: Dosyanın geçerli konumu
	/// SEEK_END: Dosyanın sonu
	
	FILE* fptr;
	fptr = fopen("01.txt", "w");
	
	fputs("Hello World!", fptr);
	fseek(fptr, 6, SEEK_SET);
	fputs("Hello World! ", fptr);
	
	fclose(fptr);
	
	return 0;
}

fwrite, fread

Dosya içeriğine yazmak/okumak için kullanılır özellikle binary olarak yazdırılır. Başarı durumunda yazdırılan öge boyutunu verir.

Syntax
size_t fwrite(const void* src, size_t size, size_t count, FILE* file);
size_t fread(void* dst, size_t size, size_t count, FILE* file);

Params

  • src: Yazılıcak data
  • size: Yazılacak data boyutu
  • count: Kaç defa yazılacak
  • file: file pointer
example.cpp
#include <stdio.h>

struct data
{
	const char* ch;
	int i;
};

int main(int argc, char** argv)
{
	FILE* fw;
	FILE* fr;
	data dt, dt2 = {0};
	
	dt.ch = "Hi";
	dt.i = 25;
	
	fw = fopen("data.dat", "wb");
	fwrite(&dt, sizeof(data), 1, fw);
	fclose(fw);
	
	fr = fopen("data.dat", "rb");
	fread(&dt2, sizeof(data), 1, fr);
	fclose(fr);
	
	printf("%s, %d", dt2.ch, dt2.i);
	
	return 0;
}

fflush

Başarı durumunda 0 değerini döner.

Syntax
int fflush(FILE* file);

Params

  • file: file pointer
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	FILE* fptr;
	
	fptr = fopen("01.txt", "w");
	for(int i = 'A'; i <= 'Z'; i++)
	{
		printf("%c", fputc(i, fptr));
		fflush(fptr);
	}
	fclose(fptr);
	
	return 0;
}

perror

Dosya Açılamaz ise Hata mesajlarını yazdırır.

Syntax
void perror(const char* str);

Params

  • str: String değeri
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	FILE* fptr;

	fptr = fopen("010.txt", "r");
	if(fptr == NULL)
		perror("Error");
	fclose(fptr);
	
	return 0;
}

ferror

Dosya açıldıktan sonra hata durmunda 1 değerini döner. Aksi taktirde 0 değeri döner.

Syntax
int ferror(FILE* file);

Params

  • file: File Pointer
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	FILE* fptr;
	int out = 0;
	
	fptr = fopen("01.txt", "r");
	if(fptr != NULL)
	{
		fprintf(fptr, "Testing");
		if(ferror(fptr))
			printf("Error Writing File");
	}
	fclose(fptr);
	
	return 0;
}

29 Ağustos 2024 Perşembe

C/CPP - Fonksiyonlar ve Kullanım Yöntemleri #5

Ağustos 29, 2024 Posted by unexpected , , No comments

static_assert

Derleme zamanında (compile-time) sabit ifadeleri kontrol etmek için kullanılan bir araçtır. Normal assert gibi çalışır, ancak çalışma zamanında değil, derleme sırasında hata kontrolü yapar.

Syntax
#define static_assert(x, y)

Params

  • x: Koşul (Expression)
  • y: Hata Mesajı (Opsiyonel)
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	static_assert(1 == 2, "Error Messages");
	
	return 0;
}

assert

Bir koşulun doğru olup olmadığını kontrol etmek için kullanılır. Eğer koşul yanlışsa, programı sonlandırır ve hangi koşulun başarısız olduğunu gösteren bir hata mesajı verir.

Syntax
#define assert(x);

Params

  • x: Koşul (Expression)
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	assert(1 == 2);
	
	return 0;
}

_assert, _wassert

Her hangi bir koşul şartı belirtilmeden bir assert messajı çıkarta biliriz.

Syntax
void _assert(const char* msg, const char* file, unsigned line);
void _wassert(const wchar_t* msg, const wchar_t* file, unsigned line);

Params

  • msg: Hata mesajı
  • file: Hatanın olduğu dosya
  • line: Hatanın olduğu satır.
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	_assert("Error Messages", "main.c", 10);
	
	_wassert(L"Error Messages", L"main.c", 10);
	
	return 0;
}

28 Ağustos 2024 Çarşamba

C/CPP - Fonksiyonlar ve Kullanım Yöntemleri #4

Ağustos 28, 2024 Posted by unexpected , , No comments

gets

Standart Input dan veri okur değişkene yazar. Başarı durumunda okunan değeri döner. Eğer bir değer boş ise dönüşü null olur. Her hangi bir hata durumda ise feof dönderir.

Syntax
char* gets(char* buf)

Params

  • buf: Buffer değeri
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	char buffer[255];
	char* ptr;
	
	ptr = gets(buffer);
	printf("Buffer: %s - ptr: %s", buffer, ptr);
	
	return 0;
}

fgets

Dosya veya Standart Input dan veri okur değişkene yazar. Başarı durumunda okunan stringi döner. Eğer bir değer boş ise dönüşü null olur. Her hangi bir hata durumda ise feof dönderir.

Syntax
char* fgets(char* buf, int size, FILE* file);

Params

  • buf: Buffer değeri
  • size: Buffer size
  • file: Dosya veya Standart Input
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	char buffer[255];
	char* ptr;
	
	ptr = fgets(buffer, 255, stdin);
	printf("Buffer: %s - ptr: %s", buffer, ptr);
	
	return 0;
}

getc, fgetc

Dosya veya Standart Input dan karakter okur. Başarı durumunda okunan karakteri döner. Eğer bir değer boş ise dönüşü -1 döner. Her hangi bir hata durumda ise feof dönderir.

Syntax
int getc(FILE* file);
int fgetc(FILE* file);

Params

  • file: Dosya veya Standart Input
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	/// 0 - stdin  - Standart Input
    /// 1 - stdout - Standart Output
    /// 2 - stderr - Standart Error
	
	int ch = -1;

	ch = getc(stdin);
	printf("Char: %c", ch);
	
	ch = fgetc(stdin);
	printf("Char: %c", ch);
	
	return 0;
}

getchar, fgetchar

Standart Input dan karakter okur. Başarı durumunda okunan karakteri döner. Eğer bir değer boş ise dönüşü -1 döner. Her hangi bir hata durumda ise feof dönderir.

Syntax
int getchar(void);
int fgetchar(void);
int _fgetchar(void);

Params

  • file: Dosya veya Standart Input
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	/// 0 - stdin  - Standart Input
    /// 1 - stdout - Standart Output
    /// 2 - stderr - Standart Error
	
	int ch = -1;

	ch = getchar();
	printf("Char: %c", ch);
	
	ch = fgetchar();
	printf("Char: %c", ch);
	
	return 0;
}

ungetc

Dosyadan okunan ilk karakteri alır verilen karakter ile değiştirilir. Aynı zamanda fgetc veya getc dönmesini engeller ilk karakteri almasını sağlar. Başarı durumunda geri konulan karakteri iade eder. Her hangi bir hata durumda ise feof dönderir.

Syntax
int ungetc(int ch, FILE* file);

Params

  • ch: Karakter
  • file: File Pointer
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	FILE* fptr;
	char dest[1024];
	int ch = 0;
	
	fptr = fopen("01.txt", "r");
	if(fptr == NULL)
	{
		perror("Error");
		return -1;
	}
	
	while(!feof(fptr))
	{
		ch = fgetc(fptr);
		(ch == '#') ? printf("%c - ", ungetc('+', fptr)) : printf("%c - ", ungetc(ch, fptr));
		fgets(dest, 1024, fptr);
		printf("%s", dest);
	}
	
	fclose(fptr);
	
	return 0;
}

10 Ağustos 2024 Cumartesi

C/CPP - Fonksiyonlar ve Kullanım Yöntemleri #3

Ağustos 10, 2024 Posted by unexpected , , No comments

puts

Standart output dan çıktı verir. Başarı durumunda sıfır, başarısız durumunda negatif değer döner. Her hangi bir hata durumda ise ferror dönderir.

Syntax
int puts(const char* str);

Params

  • str: String değeri
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	puts("Hello World!");
	
	return 0;
}

fputs

Dosya veya Standart Input, Output'a yazar. Başarı durumunda posiztif, başarısız durumunda negatif değer döner.

Syntax
int fputs(const char* str, FILE* file);

Params

  • str: String değeri
  • file: Stream değeri
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	/// 0 - stdin  - Standart Input
    /// 1 - stdout - Standart Output
    /// 2 - stderr - Standart Error
	
	fputs("Hello World!\n", stdout);
	fputs("Hello World!", __acrt_iob_func(1));
	
	return 0;
}

putc, fputc

Dosya veya Standart Input, Output'a char olarak çıktı yapar. Başarı durumunda yazılan karakteri döner. Başarız durumda -1 değerini döner.

Syntax
int putc(int ch, FILE* file);
int fputc(int ch, FILE* file);

Params

  • ch: Char değeri
  • file: Stream değeri
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	/// 0 - stdin  - Standart Input
    /// 1 - stdout - Standart Output
    /// 2 - stderr - Standart Error
	
	for(int i = 65; i <= 90; i++)
		putc(i, stdout);
		
	printf("\n");
	
	for(int i = 97; i <= 122; i++)
		putc(i, __acrt_iob_func(1));
	
	return 0;
}

putchar, fputchar

Standart Output'a char olarak çıktı yapar. Başarı durumunda yazılan karakteri döner. Başarız durumda -1 değerini döner.

Syntax
int putchar(int ch);
int fputchar(int ch);

Params

  • ch: Char değeri
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	for(int i = 65; i <= 90; i++)
		putchar(i);
		
	printf("\n");
	
	for(int i = 97; i <= 122; i++)
		putchar(i);
	
	return 0;
}

5 Ağustos 2024 Pazartesi

C/CPP - Fonksiyonlar ve Kullanım Yöntemleri #2

Ağustos 05, 2024 Posted by unexpected , , No comments

scanf

Formatlanmış olarak bir input yapılır. Başarı durumunda okuduğu input sayısını dönderir. Her hangi bir hata durumda ise ferror veya feof dönderir.

Syntax
int scanf(const char* format, ...);

Params

  • format: String Değeri
  • varargs: Array Değeri
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	char ch[5];
	int i = 0, wi = 0, count = 0;
	
	count = scanf("%s %d", &ch, &i);
	printf("Chars: %s Int: %d Count: %d\n", ch, i, count);
	
	return 0;
}

sscanf

Verilen bir src kaynağındaki veriyi formatlanmış olarak bir input alır ve bu veriyi belirlenen değişkenlere atama yapılır. Başarı durumunda ise okunan değer sayısını döner. Başarısız -1 değeri döner

Syntax
int sscanf(const char* src, const char* format, ...);

Params

  • src: Buffer değer
  • format: String değeri
  • varargs: Array değeri
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	char buf[50];
	int cx, num;
	float pi;
	
	const char* ch = "Hello_World! 21 3.14";
	cx = sscanf(ch, "%s %d %f", buf, &num, &pi);
	printf("cx: %d - buf: %s - num: %d - pi: %f\n", cx, buf, num, pi);
	
	return 0;
}

fscanf

Formatlanmış bir metni dosya veya standart input output'dan olur. Başarı durumunda okuduğu input sayısını dönderir. Her hangi bir hata durumda ise ferror ve feof dönderir.

Syntax
int fscanf(FILE* file, const char* format, ...);
  • file: Stream akışı
  • format: String değeri
  • varargs: Array değeri
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	/// 0 - stdin  - Standart Input
    /// 1 - stdout - Standart Output
    /// 2 - stderr - Standart Error
	
	char buf[50];
	int fs;
	
	fs = fscanf(stdin, "%s", &buf);
	printf("fs: %d - buf: %s", fs, buf);
	
	return 0;
}
Specifier Output Example
%d or %i Signed Decimal Integer 392
%u Unsigned Decimal Integer 7235
%o Unsigned Octal 610
%x Unsigned Hexadecimal Integer 7fa
%X Unsigned Hexadecimal Integer (Uppercase) 7Fa
%f Decimal Floating Point (Lowercase) 392.65
%F Decimal Floating Point (Uppercase) 392.65
%e Scientific Notation (Mantissa/Exponent) (Lowercase) 3.9265e+2
%E Scientific Notation (Mantissa/Exponent) (Uppercase) 3.9265e+2
%g Use the shortest representation: %e or %f 392.65
%G Use the shortest representation: %E or %F 392.65
%a Hexadecimal Floating Point (Lowercase) -0xc.90fep-2
%A Hexadecimal Floating Point (Uppercase) -0XC.90FEP-2
%c Character a
%s String of Characters sample
%p Pointer Address b8000000
%n Nothing Printed
%% % Karakteri %

1 Ağustos 2024 Perşembe

C/CPP - Fonksiyonlar ve Kullanım Yöntemleri #1

Ağustos 01, 2024 Posted by unexpected , , No comments

printf

Formatlanmış bir metni standart çıktıya (stdout) yazar. Başarı durumunda yazılan karakter uzunluğunu döndürür. Her hangi bir hata durumda ise ferror ve negatif bir sayı döner.

Syntax
int printf(const char* _Format, ...);

Params

  • format: String değeri
  • varargs: Array değeri
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	printf("Characters: %c %c \n", 'a', 65);
	printf("Decimals: %d %ld\n", 1977, 650000L);
	printf("Preceding with blanks: %10d \n", 1977);
	printf("Preceding with zeros: %010d \n", 1977);
	printf("Some different radices: %d %x %o %#x %#o \n", 100, 100, 100, 100, 100);
	printf("floats: %4.2f %+.0e %E \n", 3.1416, 3.1416, 3.1416);
	printf("Width trick: %*d \n", 5, 10);
	printf("%s \n", "A string");
    
	return 0;
}

fprintf

Formatlanmış bir metni dosya veya standart input output'a yazar. Başarı durumunda yazılan karakter uzunluğunu döndürür. Her hangi bir hata durumda ise ferror ve negatif bir sayı döner.

Syntax
int fprintf(FILE* file, const char* format, ...);

FILE* __acrt_iob_func(unsigned index);

Params

  • file: Stream akışı
  • format: String değeri
  • varargs: Array değeri
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	/// 0 - stdin  - Standart Input
    /// 1 - stdout - Standart Output
    /// 2 - stderr - Standart Error

	fprintf(stdout, "Hello World!");
    fprintf(__acrt_iob_func(1), "Hello World!");
    
	return 0;
}

sprintf

Formatlanmış bir metni stream tarafından işaret edilen tampon bir değikende tutulur. İçerikten sonra otomatik olarak sonlandırıcı bir null karakteri eklenir. Başarı durumunda yazılan toplam karakter sayısını döndürür. Başarısızlık durumunda negatif bir sayı döndürülür.

Syntax
int sprintf(char* stream, const char* format, ...);

Params

  • stream: Tampon değeri
  • format: String değeri
  • varargs: Array değeri
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	wchar_t buf[50];
	char buffer[50];
	int cx;
	
	cx = sprintf(buffer, "The half of %d is %d", 60, (60 / 2));
	printf("cx: %d - Buffer: %s", cx, buffer);
    
	return 0;
}

snprintf

Formatlanmış bir metni stream tarafından işaret edilen tampon bir değikende tutulur. İçerikten sonra otomatik olarak sonlandırıcı bir null karakteri eklenir. Başarı durumunda yazılan toplam karakter sayısını döndürür. Başarısızlık durumunda negatif bir sayı döndürülür.

Syntax
int snprintf(char* stream, size_t n, const char* format, ...);

Params

  • stream: Tampon değeri
  • n: Tampon boyutu
  • format: String değeri
  • varargs: Array değeri
example.cpp
#include <stdio.h>

int main(int argc, char** argv)
{
	wchar_t* buffer[150];
	char buf[150];
	int cx, cx2;
	
	cx = snprintf(buf, 150, "The half of %d is %d", 60, (60 / 2));
	cx2 = snprintf((buf + cx), (150 - cx), ", and the half of that is %d.", (60 / 2 / 2));
	printf("cx: %d - cx2: %d - Buffer: %s", cx, cx2, buf);
    
	return 0;
}
Specifier Output Example
%d or %i Signed Decimal Integer 392
%u Unsigned Decimal Integer 7235
%o Unsigned Octal 610
%x Unsigned Hexadecimal Integer 7fa
%X Unsigned Hexadecimal Integer (Uppercase) 7Fa
%f Decimal Floating Point (Lowercase) 392.65
%F Decimal Floating Point (Uppercase) 392.65
%e Scientific Notation (Mantissa/Exponent) (Lowercase) 3.9265e+2
%E Scientific Notation (Mantissa/Exponent) (Uppercase) 3.9265e+2
%g Use the shortest representation: %e or %f 392.65
%G Use the shortest representation: %E or %F 392.65
%a Hexadecimal Floating Point (Lowercase) -0xc.90fep-2
%A Hexadecimal Floating Point (Uppercase) -0XC.90FEP-2
%c Character a
%s String of Characters sample
%p Pointer Address b8000000
%n Nothing Printed
%% % Karakteri %