Sic Parvis Magna

26 Kasım 2024 Salı

PHP Programlama Temel Anlatım

Kasım 26, 2024 Posted by unexpected No comments

Değişkenler

PHP'de değişken tipleri yoktur. Atanan değere göre otomatik olarak değişkenin tipi verilir. Bir değişkenin veri tipinin ne olduğunu görmek için gettype(); function ile alabiliriz veya settype(); function ile tipini belirleye biliriz.

echo(); function ile tanımladığımız değişkenleri yazdıra biliriz. PHP'de birleştirme operatörü olarak "." (nokta) karakteri kullanılır.

index.php
$var1 = "String";
$var2 = 25;
$var3 = 3.14;

echo "Var1: $var1, Var2: $var2, Var3: $var3";
echo "<br>---------------------------------------<br>";
echo "Value: " . $var1 . "
"; echo "Type: " . gettype($var1);

Sabitler

Sabit tanımları aşağıdaki gibi tanımlanır. Değişkenlerden farkı değiştirelemez olamlarıdır. Bu yüzden tanımlandıkları yerde bir kez değer atanır istenilen her yerde kullanılır.

index.php
define("CONST_STR", "Sabit Varaible");
define("CONST_PI", 3.14);

echo "Sabit: " . CONST_STR . "<br>";
echo "Pi: " . CONST_PI;

Array Tanımı

Arrayleri içlerin de bir den fazla değerler tutabilen değişkenler olarak tanımlaya biliriz.

Arraylerin iki farklı kullanımları vardır:

  • Eski Kullanım: $array1 = array();
  • Modern Kullanım: $array2 = [];

Array içine eleman eklemenin temelde iki yolu vardır:

  • $array1[] = "Eleman 1";
  • array_push($array2, "Eleman 2");

Her eklenen değerlerin key değerleri 0'dan başlayarak kaldığı yerden veri eklendikçe artarak devam eder. Arrayleri echo function ile direk olarak yazdırmamız mümkün değildir. Bunun için var_dump(), print_r() functionları kullanılmalıdır.

index.php
$array1 = array();
$array2 = [];

$array2[] = "Eleman 1";
$array2[] = "Eleman 2";
$array2[] = "Eleman 3";

var_dump($array2);
echo "<br>";
print_r($array2);

Eğer eklenen valueların keylerini kendimiz vermek istiyorsak array'e eleman eklerken köşeli parantez içinde belirtebiliriz.

index.php
$array1["key1"] = "value 1"

Bir arraydeki değerleri satır satır çekmenin yolu ise foreach'tir

index.php
foreach($array2 as $value)
{
	echo $value . "<br>";
}

Bir de arrayler de boyut dediğimiz bir kavram vardır. Array içine bir array ataması gerçekleştirdiğimiz de bu array aslında 2 boyutlu bir array haline gelir.

index.php
$array3 = [];
$array3[] = ["0. Eleman 1", "0. Eleman 2", "0. Eleman 3"];
$array3[] = ["1. Eleman 1", "1. Eleman 2", "1. Eleman 3"];
$array3[] = ["2. Eleman 1", "2. Eleman 2", "2. Eleman 3"];

print_r($array3);
echo "<br>";
foreach($array3 as $value)
{
	print_r($value);
	echo "<br>";
}

Aritmetik Operatörler

  • (+) Toplama Operatörü
  • (-) Çıkartma Operatörü
  • (*) Çarpma Operatörü
  • (/) Bölme Operatörü
  • (%) Mod Operatörü
  • ($i++) $i değişkeni işlendikten sonra içindeki değeri 1 artır.
  • ($i--) $i değişkeni işlendikten sonra içindeki değeri 1 azalt.
  • (++$i) $i değişkenin içindeki değeri 1 artırdıktan sonra işle.
  • (--$i) $i değişkenin içindeki değeri 1 azalttıktan sonra işle.
index.php
$x = 30;
$y = 2;

echo ($x + $y) . "<br>"; // 32
echo ($x - $y) . "<br>"; // 28
echo ($x * $y) . "<br>"; // 60
echo ($x / $y) . "<br>"; // 15
echo ($x % $y) . "<br>"; // 0

Atama Operatörleri

  • $x += $y; -> $x = $x + $y;
  • $x -= $y; -> $x = $x - $y;
  • $x *= $y; -> $x = $x * $y;
  • $x /= $y; -> $x = $x / $y;
index.php
echo ($x += $y) . "<br>"; // $x'in yeni değer 32 oldu
echo ($x -= $y) . "<br>"; // $x'in yeni değer 32 olduğundan 32 - 2 = 30. $x tekrardan 30 oldu
echo ($x *= $y) . "<br>"; // 30 * 2 den $x'in yeni değeri 60 oldu
echo ($x /= $y) . "<br>"; // 60 / 2 işlemi yapılacağından $x tekrardan 30 oldu

Karşılaştırma Operatörler

  • (==) Eşittir.
  • (!=) Değil Eşittir.
  • (<>) Değil Eşittir.
  • (<) Küçüktür.
  • (<=) Küçük Eşittir.
  • (>) Büyüktür.
  • (>=) Büyük Eşittir.
index.php
$x = 10;
$y = 20;

if($x == 10)
{
	echo "Eşittir. <br>";
}
else
{
	echo "Eşit Değildir. <br>";
}


if($x == 10)
{
	echo "10'a Eşittir. <br>";
}
else if($x == 13)
{
	echo "13'e Eşittir. <br>";
}
else
{
	echo "Eşit Değildir. <br>";
}

AND ve OR operatörleri ile birden fazla kontrol sağlaya biliriz.

  • and her iki koşulun sağlandığı durumlar da true döndürür. && olarak da kullanılır.
  • or her iki koşuldan biri bile doğru ise true döndürür. || olarak da kullanılır.
index.php
if($x >= 5 && $x <= 15)
{
	echo "5 ile 15 arasındadır. <br>";
}
else
{
	echo "değildir. <br>";
}

$str = "zeynep";
if($str == "ali" || $str == "zeynep")
{
	echo "Ya ali ya zeynep dir. <br>";
}
else
{
	echo "değildir. <br>";
}

Döngüler

$i'nin ilk değeri 0'dır, $i küçük eşit 10 koşulu sağlandığı sürece $i'yi 1 artır

index.php
for($i = 0; $i <= 10; $i++)
{
    echo "i'nin şuanki değeri : " . $i . "<br />";
}

Koşul sağlandığı sürece, yani içindeki koşulun sonucu true olduğu sürece blok içindeki işlemler yapılır.

index.php
$i = 0;
while($i <= 10)
{
    echo "a'nin şuanki değeri : " . $i . "<br />";
    $i++;
}

Koşul kontrol edilmeden önce bloktaki işlemler yapılır, sonra koşul kontrol edilir. $b 0'a eşit olduğu sürece döngünün dönmesi lazım. Daha ilk adımdan koşul sağlanmamasına rağmen, ilk önce blok çalıştığından ekrana yazı basılır.

index.php
$i = 1;
do
{
    echo "blok içindeki işlemler <br />";
}while($i == 0);

Dosya Dahil Etmek

Başka bir dosyayı 2 şekilde dahil edebiliriz.

  • require Dahil etmek istediğimiz dosya yok ise ekrana hata basıp sonraki işlemleri yapmaz.
  • include Dahil etmeye çalıştığımız dosya yok ise ekrana hata basar ve sayfaki diğer işlemleri yapmaya devam eder.
  • require_once ve include_once 1 dosya 1 den fala kez çağrılırsa sadece 1 kere çağrılmış gibi davranmasını sağlar.
index.php
require "external.php";
include "external.php";

require_once "external.php";
include_once "external.php";

Function Oluşturmak

PHP'de function aşağıdaki gibi oluşturulur.

index.php
function func1()
{
	echo "Parameresiz Func";
}

function func2()
{
	return "Parameresiz Func";
}

function func3($x, $y)
{
	echo "Sonuc: " . ($x + $y);
}

function func4($x, $y)
{
	return $x + $y;
}

Class ve Erişim Belirtecleri

  • public her yerden ulaşılabilen.
  • private sadece oluşturulduğu class içinde çağrılabilen
  • protected sadece oluşturulduğu ve miras alınan classlarda çağrılabilen
index.php
class Student
{
    private $name = "Zeynep";
    private $age = "23";

    public function getName()
	{
        echo $this->name;
    }
}

$student = new Student;
student -> getName();

Constructures

  • __construct class'tan yeni bir nesne oluşturulduğunda yapılacak işlemler
  • __destruct class sonlandığında yapılacak işlemler
index.php
class Constructure
{
    function __construct()
	{
        echo "ben doğdum <br />";
    }

    function __destruct()
	{
        echo "ben öldüm <br />";
    }
}

$const = new Constructure;

Miras Almak

index.php
class Hayvan
{
    public function nefesAl()
	{
        echo "ben enfes alıyorum <br />";
    }

    public function yemekYe()
	{
        echo "ben yemek yiyorum <br />";
    }

    public function uyu()
	{
        echo "ben uyuyorum <br />";
    }
}

class Kedi extends Hayvan
{
    private $adi;

    function __construct($gelenad)
	{
        $this->adi = $gelenad;
        echo "ben $this->adi isminde bir kediyim ve doğdum <br />";
    }

    public function kos()
	{
        echo "ben koşuyorum çünkü kediyim <br />";
    }

    function __destruct()
	{
        echo "ben $this->adi ismindeki kediydim öldüm <br />";
    }
}

class Kus extends Hayvan
{
    private $adi;

    function __construct($gelenad)
	{
        $this->adi = $gelenad;
        echo "ben $this->adi isminde bir kuşum ve doğdum <br />";
    }

    public function uc()
	{
        echo "ben uçabiliyorum çünkü kuşum <br />";
    }

    function __destruct()
	{
        echo "ben $this->adi ismindeki kuştum öldüm <br />";
    }
}

$cat = new Kedi("tekir");
$cat -> yemekYe(); 		// Hayvan class'ı miras alındığından Hayvan classının methodu kullanılabilir.
$cat -> kos(); 			// kendi class'ında bir methodu kullandı
// $cat -> uc();		// hata! kuşa ait olan bir methodu kullandı

$bird = new Kus("boncuk");
$bird -> yemekYe(); 	// Hayvan class'ı miras alındığından Hayvan classının methodu kullanılabilir.
$bird -> uc(); 			// kendi class'ında bir methodu kullandı
// $bird -> kos(); 		// hata! kediye ait olan bir methodu kullandı

Cookie ve Session Oluşturmak

Sayfada session ile işlem yapmak istiyorsam session_start(); demeliyim

Session ve Cookie, unutulmayan değişkenlerdir. Bu sayfada 1 kere tanımladıktan sonra başka sayfada istediğiniz gibi kullanabilirsiniz.

Farkları nedir:

  • Cookie, browser'ınızda tutulur. 3. parametrede unix time stamp formatı ile girilen zaman geldiğinde cookie kendini unset eder yani siler
  • Session, server'da tutulur. Browser kapatıldığında serverdaki session dosyası kendini unset eder

Cookie Oluşturmak

index.php
setcookie("bilgiler", "adim=zeynep,soyad=asd", time() + (7 * 24 * 60 * 60) );

// Anahtarı 'bilgiler' olan, içinde 'adim=zeynep,soyad=asd' değerini taşıyan ve 
// tam 1 hafta sonra bugün bu saatte yok olacak bir cookie set ettim.
echo $_COOKIE["bilgiler"] . "<br />";

Session Oluşturmak

index.php
$_SESSION["bilgiler"] = "adım = ahmet, soyadım = mehmed";

echo $_SESSION["bilgiler"] . "<br />";

Try Catch Tanımı

index.php
$str = "zeynep deneme SELECT dfsdf ,sdfsdfds ";
try
{
    if(strstr($str, "SELECT"))
	{
        throw new Exception("ismin içinde select kelimesi var");
    }
	
    echo "eğer hata yok ise, yani str değişkenin içinde SELECT kelimesi geçmiyor, yeni bir Exception oluşturulmamış ise yapılacak işlemler";
}
catch(Exception $e)
{
    echo "hata var! " . $e -> getFile() . " dosyasının " . $e -> getLine() . ". satırında yeni bir hata tespit edilmiş!. hata mesajının içeriği = " . $e -> getMessage();
}

23 Kasım 2024 Cumartesi

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

Kasım 23, 2024 Posted by unexpected , , No comments

memcmp

Belirlenen her iki değeri biri bir ile belirlenen karakter sayısı kadar karşılaştırır. Başarılı ise 0 değil ise -1 veya 1 değeri döner.

Syntax
int memcmp(const void* buf1, const void* buf2, size_t size);

Params

  • buf1: Sabit data değeri
  • buf2: Sabit data değeri
  • size: Karşılaştırılıcak Uzunluk
example.cpp
#include <stdio.h>
#include <string.h>

int main(int argc, char** argv)
{
	char buffer1[] = "memcmp";
	char buffer2[] = "memcmp";
	
	printf("%d", memcmp(buffer1, buffer2, sizeof(buffer2)));
	
	return 0;
}

memcpy

Belirtilen kaynak (src) değerini hedef (dst) değerine koplayalar. Başarlı ise hedef değerini döner. Başarısız ise NULL değerini döner.

Syntax
void* memcpy(void* dst, const void* src, size_t size);

Params

  • dst: Hedef
  • src: Kaynak
  • size: Kaynak Boyutu
example.cpp
#include <stdio.h>
#include <string.h>

struct Data
{
	char name[22];
	int age;
};

int main(int argc, char** argv)
{
	char src[] = "Hello World!";
	char dest[50];
	memcpy(&dest, &src, sizeof(src));
	printf("%s -- ", dest);
	
	Data d1, d2;
	memcpy(&d1.name, &src, sizeof(src));
	d1.age = 22;
	
	memcpy(&d2, &d1, sizeof(d1));
	printf("Name: %s - Age: %d", d2.name, d2.age);
	
	return 0;
}

memset

Belitilen kaynak veya hedef (dst) içerisinde yeni bir değer ataması yapılamasını sağlar. Burada val değeri ile belirlenen yeni değeri belirttiğimiz index den önceki tüm değerleri değişir. Başarılı ise dst değerini döner.

Syntax
void* memset(void* dst, int val, size_t size);

Params

  • dst: Kaynak veya Hedef Değer
  • val: Karakter veya ASCII Değer
  • size: Index veya değişecek index değeri
example.cpp
#include <stdio.h>
#include <string.h>

int main(int argc, char** argv)
{
	char str[] = "This is a sample memset";
	memset(str, '-', 4);
	printf("%s", str);
	
	return 0;
}

memmove

Belirlenen src değerini dst değeri içerisine belirtilen uzunluk kadar taşır. Başarılı ise dst değerini döner. Başarısız ise NULL döner.

Syntax
void* memmove(void* dst, const void* src, size_t size);

Params

  • dst: Hedef değer
  • src: Taşınacak değer
  • size: Index veya taşınacak index değeri
example.cpp
#include <stdio.h>
#include <string.h>

struct Data
{
	char name[22];
	int age;
};

int main(int argc, char** argv)
{
	char src[] = "memmove";
	
	char dest[50];
	memmove(&dest, &src, sizeof(src));
	printf("%s -- ", dest);
	
	Data d1, d2;
	memmove(&d1.name, &src, sizeof(src));
	d1.age = 22;
	
	memmove(&d2, &d1, sizeof(d1));
	printf("Name: %s - Age: %d", d2.name, d2.age);
	
	return 0;
}

memchr

Belitilen buf içerisinde verilen val değerindeki karakteri bulur. Return olarak bulunan karakterden sonraki kısmını döner.

Syntax
void* memchr(const void* buf, int val, size_t maxCount);

Params

  • buf: Kaynak Değer
  • val: Karakter veya ASCII Değer
  • size: Kaynak Uzunluk
example.cpp
#include <stdio.h>
#include <string.h>

int main(int argc, char** argv)
{
	char* pch;
	char str[] = "memchr";
	
	pch = (char*)memchr(str, 'c', sizeof(str));
	(pch != NULL) ? printf("Found at position: %d", pch - str + 1) : printf("Not Found");
	
	return 0;
}

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

Kasım 23, 2024 Posted by unexpected , , No comments

strlen

Belirlenen bir char* değerinin uzunluğunu size_t olarak döner.

Syntax
size_t strlen(const char* str);

Params

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

int main(int argc, char** argv)
{
	const char* str = "This is a sample strlen";
	
	size_t len = strlen(str);
	printf("Length: %ld", len);
	
	return 0;
}

strchr

Belirlenen bir const char* değeri içinde verilen int tipindeki karakteri bulur. Başarısız ise NULL değeri döner.

Syntax
char* strchr(const char* str, int val);

Params

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

int main(int argc, char** argv)
{
	const char* str = "strchr";
	char* pch;
	
	pch = strchr(str, 'r');
	while(pch != NULL)
	{
		printf("Found at %d\n", pch - str + 1);
		pch = strchr(pch + 1, 'r');
	}
	
	return 0;
}

strrchr

Belirlenen bir const char* değeri içinde verilen int tipindeki karakteri bulur. Başarısız ise NULL değeri döner.

Syntax
char* strrchr(const char* _Str, int _Ch);

Params

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

int main(int argc, char** argv)
{
	const char* str = "strrchr";
	char* pch;
	
	pch = strrchr(str, 'r');
	while(pch != NULL)
	{
		printf("Found at %d\n", pch - str + 1);
		pch = strrchr(pch + 1, 'r');
	}
	
	return 0;
}

strdup

Verilen const char* değerini char* olarak geri döner. Başarısız ise NULL değerini döner.

Syntax
char* strdup(const char* src);

Params

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

int main(int argc, char** argv)
{
	const char* str = "This is a sample strdup";
	
	char* pch = strdup(str);
	printf("%d", pch);
	
	return 0;
}

strcmp

Belirlenen her iki değeri biri bir ile karşılaştırır. Başarılı ise 0 değil ise -1 değeri döner.

Syntax
int strcmp(const char* _Str1, const char* _Str2);

Params

  • str1: Sabit string değeri
  • str2: Sabit string değeri
example.cpp
#include <stdio.h>
#include <string.h>

int main(int argc, char** argv)
{
	char buffer1[] = "strcmp";
	char buffer2[] = "strcmp";
	
	printf("%d", strcmp(buffer1, buffer2));
	
	return 0;
}

strncmp

Belirlenen her iki değeri biri bir ile belirlenen karakter sayısı kadar karşılaştırır. Başarılı ise 0 değil ise -1 değeri döner.

Syntax
int strncmp(const char* str1, const char* str2, size_t maxCount);

Params

  • str1: Sabit string değeri
  • str2: Sabit string değeri
  • maxCount: Karşılaştırılıcak Uzunluk
example.cpp
#include <stdio.h>
#include <string.h>

int main(int argc, char** argv)
{
	char str[][5] = {"R2D2", "C3PO", "R2A6"};
	
	for(int n = 0; n < 3; n++)
		if(!strncmp(str[n], "R2xx", 2))
			printf("Found %s\n", str[n]);
	
	return 0;
}

strncasecmp

Belirlenen her iki değeri biri bir ile belirlenen karakter sayısı kadar büyük küçük kontrolü olmaksızın karşılaştırır. Başarılı ise 0 değil ise -1 değeri döner.

Syntax
int strncasecmp(const char* str1, const char* str2, size_t maxCount);

Params

  • str1: Sabit string değeri
  • str2: Sabit string değeri
  • maxCount: Karşılaştırılıcak Uzunluk
example.cpp
#include <stdio.h>
#include <string.h>

int main(int argc, char** argv)
{
	char str[][5] = {"R2D2", "C3PO", "R2A6"};
	
	for(int n = 0; n < 3; n++)
		if(!strncasecmp(str[n], "r2xx", 2))
			printf("Found %s\n", str[n]);
	
	return 0;
}

strcpy

Belirtilen kaynak (src) değerini hedef (dst) değerine koplayalar. Başarlı ise hedef değerini döner. Başarısız ise NULL değerini döner.

Syntax
char* strcpy(char* dest, const char* source);

Params

  • dest: Hedef değeri
  • source: Kaynak değeri
example.cpp
#include <stdio.h>
#include <string.h>

struct Data
{
	char name[22];
	int age;
};

int main(int argc, char** argv)
{
	char src[] = "strcpy";
	
	char dest[50];
	strcpy(dest, src);
	printf("%s -- ", dest);
	
	Data d1;
	strcpy(d1.name, src);
	d1.age = 22;
	
	printf("Name: %s - Age: %d", d1.name, d1.age);
	
	return 0;
}

strncpy

Belirtilen kaynak (src) değerini hedef (dst) değerine koplayalar. Başarlı ise hedef değerini döner. Başarısız ise NULL değerini döner.

Syntax
char* strncpy(char* _Dest, const char* _Source, size_t _Count);

Params

  • dest: Hedef değeri
  • source: Kaynak değeri
  • count: Kaynak Boyutu
example.cpp
#include <stdio.h>
#include <string.h>

int main(int argc, char** argv)
{
	char src[] = "strncpy";
	
	char dest[50];
	strncpy(dest, src, sizeof(src));
	printf("%s", dest);
	
	return 0;
}

strcat

Kaynağın bir kopyasını alıp dest ile birleştirir. Dönüş olarak dest döndürülür.

Syntax
char* strcat(char* dest, const char* source);

Params

  • dest: Hedef değeri
  • source: Kaynak değeri
example.cpp
#include <stdio.h>
#include <string.h>

int main(int argc, char** argv)
{
	char src[] = "strcat";
	char dest[50] = "--> ";
	
	strcat(dest, src);
	printf("%s", dest);
	
	return 0;
}

strncat

Kaynağın bir kopyasını alıp dest ile birleştirir. Count olarak stringin ne kadar bölümünü birleştirsin. Dönüş olarak dest döndürülür.

Syntax
char* strncat(char* dest, const char* source, size_t count);

Params

  • dest: Hedef değeri
  • source: Kaynak değeri
  • count: Kaynağın Uzunluğu
example.cpp
#include <stdio.h>
#include <string.h>

int main(int argc, char** argv)
{
	char src[] = "strncat";
	char dest[50] = "--> ";
	
	strncat(dest, src, 2);
	printf("%s", dest);
	
	return 0;
}

17 Kasım 2024 Pazar

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

Kasım 17, 2024 Posted by unexpected , , No comments

clock

Program tarafından tüketilen işlemci süresini döner. Saniye cinsinde görmek için CLOCKS_PER_SEC değeri ile bölünür. Başarısız durumu -1 döner.

Syntax
clock_t clock(void);

Params

  • void: Değer almaz
example.cpp
#include <time.h>

int main(int argc, char** argv)
{
	clock_t clk = clock();
	
	printf("%ld\n", clk / CLOCKS_PER_SEC);
	
	return 0;
}

time

Geçerli Takvimi ve saati unix timestamp olarak verir. Başarısız drumunda -1 değerini döner.

Syntax
time_t time(time_t* time);

Params

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

int main(int argc, char** argv)
{
	time_t t1, t2;
	
	t2 = time(&t1);
	
	printf("%ld %ld\n", t1, t2);
	printf("%ld", time(NULL));
	
	return 0;
}

difftime

Başlangıç ve bitiş arasındaki saniyeyi döner.

Syntax
double difftime(time_t time1, time_t time2);

Params

  • time1: 1. Zaman değeri
  • time2: 2. Zaman değeri
example.cpp
#include <time.h>

int main(int argc, char** argv)
{
	time_t now, end;
	
	time(&now);
	time(&end);
	
	double dif = difftime(now, end);
	printf("%f", dif);
	
	return 0;
}

localtime

Timestamp değerinden yerel zamanı döner.

Syntax
struct tm* localtime(const time_t* time);

Params

  • time: Zaman değeri
example.cpp
#include <time.h>

int main(int argc, char** argv)
{
	time_t timer;
	struct tm* timeinfo;
	
	time(&timer);
	timeinfo = localtime(&timer);
	
	printf("Sec: %d\n", timeinfo->tm_sec);
	printf("Min: %d\n", timeinfo->tm_min);
	printf("Hour: %d\n", timeinfo->tm_hour);
	printf("Day: %d\n", timeinfo->tm_mday);
	printf("Ay: %d\n", timeinfo->tm_mon);
	printf("Year: %d\n", timeinfo->tm_year);
	printf("Week Day: %d\n", timeinfo->tm_wday);
	printf("Year Day: %d\n", timeinfo->tm_yday);
	printf("%d", timeinfo->tm_isdst);
	
	return 0;
}

mktime

Struct tipindeki değeri timestamp olarak dönüştürür.

Syntax
time_t mktime(struct tm* time);

Params

  • time: Zaman değeri
example.cpp
#include <time.h>

int main(int argc, char** argv)
{
	time_t now;
	struct tm* newyear;
	
	time(&now);
	newyear = localtime(&now);
	
	printf("%ld", mktime(newyear));
	
	return 0;
}

16 Kasım 2024 Cumartesi

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

Kasım 16, 2024 Posted by unexpected , , No comments

strtod

Verilen array içindeki iki adet double sayıyının birini verilen char* değerine yazar değerini ise çıktı olarak dönüş sağlar. Başarı durumunda string den double sayıya dönüşüm sağlar. Başarısız durumunda dönüşü 0 olarak döner.

Syntax
double strtod(const char* str, const char** endptr);

Params

  • str: Dönüştürülcek değer
  • endptr: Tampon değer
example.cpp
#include <stdlib.h>

int main(int argc, char** argv)
{
	char sz[] = "365.24 29.53";
	char* endptr;
	double d1, d2;
	
	d1 = strtod(sz, &endptr);
	d2 = strtod(endptr, NULL);
	
	printf("%f %f", d1, d2);
	
	return 0;
}

strtof

Verilen array içindeki iki adet float sayıyının birini verilen char* değerine yazar değerini ise çıktı olarak dönüş sağlar. Başarı durumunda string den float sayıya dönüşüm sağlar. Başarısız durumunda dönüşü 0 olarak döner.

Syntax
float strtof(const char* str, const char** endptr);

Params

  • str: Dönüştürülcek değer
  • endptr: Tampon değer
example.cpp
#include <stdlib.h>

int main(int argc, char** argv)
{
	char sz[] = "365.2 29.5";
	char* endptr;
	double f1, f2;
	
	f1 = strtof(sz, &endptr);
	f2 = strtof(endptr, NULL);
	
	printf("%f %f", f1, f2);
	
	return 0;
}

strtol

Sayıların hangi tabanda işleneceği belirtilir. Başarı durumunda string den long int tipine dönüşüm sağlar. Başarısız durumunda dönüşü 0 olarak döner.

Syntax
long int strtol(const char* src, char** dst, int base);

Params

  • src: Parse edilicek kaynak
  • dst: Hedef bellek
  • base: Çevrilecek taban
example.cpp
#include <stdlib.h>

int main(int argc, char** argv)
{
	char sz[] = "1856892505 17b00a12b -01100011010110000010001101100 0x6fffff";
	char* endptr;
	long int l1, l2, l3, l4;
	
	l1 = strtol(sz, &endptr, 10);
	l2 = strtol(endptr, &endptr, 16);
	l3 = strtol(endptr, &endptr, 2);
	l4 = strtol(endptr, &endptr, 0);
	
	printf("%ld %ld %ld %ld", l1, l2, l3, l4);
	
	return 0;
}

strtold

Sayıların hangi tabanda işleneceği belirtilir. Başarı durumunda string den long double tipine dönüşüm sağlar. Başarısız durumunda dönüşü 0 olarak döner.

Syntax
long double strtold(const char* src, char** dst);

Params

  • src: Parse edilicek kaynak
  • dst: Hedef bellek
example.cpp
#include <stdlib.h>

int main(int argc, char** argv)
{
	char sz[] = "365.24 29.53";
	char* endptr;
	long double l1, l2;
	
	l1 = strtold(sz, &endptr);
	l2 = strtold(endptr, NULL);
	
	printf("%Lf %Lf", l1, l2);
	
	return 0;
}

strtoll

Sayıların hangi tabanda işleneceği belirtilir. Başarı durumunda string den long long int tipine dönüşüm sağlar. Başarısız durumunda dönüşü 0 olarak döner.

Syntax
long long int strtoll(const char* src, char** dst, int base);

Params

  • src: Parse edilicek kaynak
  • dst: Hedef bellek
  • base: Çevrilecek taban
example.cpp
#include <stdlib.h>

int main(int argc, char** argv)
{
	char sz[] = "1856892505 17b00a12b -01100011010110000010001101100 0x6fffff";
	char* endptr;
	long long int l1, l2, l3, l4;
	
	l1 = strtoll(sz, &endptr, 10);
	l2 = strtoll(endptr, &endptr, 16);
	l3 = strtoll(endptr, &endptr, 2);
	l4 = strtoll(endptr, &endptr, 0);
	
	printf("%llu %llu %llu %llu", l1, l2, l3, l4);
	
	return 0;
}

strtoull

Sayıların hangi tabanda işleneceği belirtilir. Başarı durumunda string den unsigned long long int tipine dönüşüm sağlar. Başarısız durumunda dönüşü 0 olarak döner.

Syntax
unsigned long long int strtoull(const char* src, char** dst, int base);

Params

  • src: Parse edilicek kaynak
  • dst: Hedef bellek
  • base: Çevrilecek taban
example.cpp
#include <stdlib.h>

int main(int argc, char** argv)
{
	char sz[] = "1856892505 17b00a12b -01100011010110000010001101100 0x6fffff";
	char* endptr;
	unsigned long long int l1, l2, l3, l4;
	
	l1 = strtoull(sz, &endptr, 10);
	l2 = strtoull(endptr, &endptr, 16);
	l3 = strtoull(endptr, &endptr, 2);
	l4 = strtoull(endptr, &endptr, 0);
	
	printf("%llu %llu %llu %llu", l1, l2, l3, l4);
	
	return 0;
}

strtoul

Sayıların hangi tabanda işleneceği belirtilir. Başarı durumunda string den unsigned long int tipine dönüşüm sağlar. Başarısız durumunda dönüşü 0 olarak döner.

Syntax
unsigned long int strtoul(const char* src, char** dst, int base);

Params

  • src: Parse edilicek kaynak
  • dst: Hedef bellek
  • base: Çevrilecek taban
example.cpp
#include <stdlib.h>

int main(int argc, char** argv)
{
	char sz[] = "1856892505 17b00a12b -01100011010110000010001101100 0x6fffff";
	char* endptr;
	unsigned long int l1, l2, l3, l4;
	
	l1 = strtoul(sz, &endptr, 10);
	l2 = strtoul(endptr, &endptr, 16);
	l3 = strtoul(endptr, &endptr, 2);
	l4 = strtoul(endptr, &endptr, 0);
	
	printf("%llu %llu %llu %llu", l1, l2, l3, l4);
	
	return 0;
}

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

Kasım 16, 2024 Posted by unexpected , , No comments

atof

Başarı durumunda string den double sayısına dönüşüm sağlar. Başarısız durumunda dönüşü 0.0 olarak döner.

Syntax
double atof(const char* str);

Params

  • str: Dönüştürülcek değer
example.cpp
#include <stdlib.h>

int main(int argc, char** argv)
{
	printf("%f", atof("3.14"));
	
	return 0;
}

atoi

Başarı durumunda string den int tipine dönüşüm sağlar. Başarısız durumunda dönüşü 0 olarak döner.

Syntax
int atoi(const char* str);

Params

  • str: Dönüştürülcek değer
example.cpp
#include <stdlib.h>

int main(int argc, char** argv)
{
	printf("%f", atoi("22"));
	
	return 0;
}

atol

Başarı durumunda string den long int tipine dönüşüm sağlar. Başarısız durumunda dönüşü 0 olarak döner.

Syntax
long int atol(const char* str);

Params

  • str: Dönüştürülcek değer
example.cpp
#include <stdlib.h>

int main(int argc, char** argv)
{
	printf("%ld", atol("22"));
	
	return 0;
}

atoll

Başarı durumunda string den long long int tipine dönüşüm sağlar. Başarısız durumunda dönüşü 0 olarak döner.

Syntax
long long int atoll(const char* str);

Params

  • str: Dönüştürülcek değer
example.cpp
#include <stdlib.h>

int main(int argc, char** argv)
{
	printf("%lld", atoll("22"));
	
	return 0;
}