MyFitnessPal, Kilo kontrolü, Kaç gram kaç kaşık

Bu basit bir matematik; aldığından fazlasını harcarsan kilo verirsin. Aldıkların da yeteri kadar ve doğru karbonhidrat, protein ve yağ oranlarında olursa sağlığını da kaybetmezsin.

Bunu sağlamak adına iyi bir tool olarak

https://www.myfitnesspal.com/

veya android için

https://play.google.com/store/apps/details?id=com.myfitnesspal.android&hl=tr

tavsiye edebilir. iOS için de mevcut ama onu meraklısına bırakıyorum.

Porsiyonlar için de aşağıdaki tabloyu kullanabilirsiniz.

ET PORSİYONU:

YİYECEKLER	1 PORSİYON ÖLÇÜSÜ	MİKTAR(g)
KÖFTE	1 ADET (yemek kaşığı büyüklüğünde)	30
KIRMIZ ET	1 YEMEK KAŞIĞI	30
PİRZOLA-BİFTEK	1 KÜÇÜK BOY	30
NUAR	1 İNCE DİLİM	30
TAVUK	1 YUMURTA BÜYÜKLÜĞÜNDE	40
BALIK	1 YUMURTA BÜYÜKLÜĞÜNDE	40
MİDYE	5 ADET	60
KARİDES	5 ADET	60
İSTAKOZ	1 ORTA BOY	60
SOSİS	YARIM ADET	30
KOKTEYL SOSİS	1 ADET	30
SALAM	1 DİLİM	30
JAMBON	1 DİLİM	30
SUCUK	4 HALKA	30
YUMURTA	1 ADET	30
BEYAZ PEYNİR	1 KİBRİT KUTUSU BÜYÜKLÜĞÜNDE	30
DİL PEYNİRİ	1 KİBRİT KUTUSU BÜYÜKLÜĞÜNDE	30
KAŞAR PEYNİRİ	2/3 KİBRİT KUTUSU BÜYÜKLÜĞÜNDE (1ince dilim)	20
GRAVYER PEYNİRİ	1 KİBRİT KUTUSU BÜYÜKLÜĞÜNDE	30
LOR PEYNİRİ	YARIM ÇAY BARDAĞI	70
TULUM PEYNİRİ	1 YEMEK KAŞIĞI	20
KURUBAKLAGİLLER (Kurufasülye-Nohut-Mercimek)	4 YEMEK KAŞIĞI	25

EKMEK PORSİYONU:

YİYECEKLER	1 PORSİYON ÖLÇÜSÜ	MİKTAR(g)
EKMEK(Buğday-Çavdar-Mısır)	1 İNCE DİLİM	25
KEPEKLİ EKMEK	1 İNCE DİLİM	25
ÇORBA(Bütün Çorbalar)	1 KÜÇÜK KASE
PİRİNÇ PİLAVI	2 YEMEK KAŞIĞI	15
BULGUR PİLAVI	2 YEMEK KAŞIĞI	15
MAKARNA	2 YEMEK KAŞIĞI	15
KUSKUS	2 YEMEK KAŞIĞI	15
YUFKA	¼ ADET	25
PATATES	1 ORTA BOY	90
KESTANE	3 KÜÇÜK BOY	30
PATLAMIŞ MISIR	4 YEMEK KAŞIĞI - ½ KOÇAN	20
HAŞLANMIŞ MISIR	4 YEMEK KAŞIĞI - ½ KOÇAN	20
LEBLEBİ(Beyaz-Sarı)	1 ÇAY BARDAĞI	50
ETİMEK	2 DİLİM	20
GRİSİNİ	2 ADET	20
GALETA	1 ADET	20
ÇUBUK KRAKER	10 ADET	20
TATLI BİSKÜVİ	2 ADET	20
TUZLU BİSKÜVİ	2 ADET	20
DİYET BİSKÜVİ	4 ADET	20
SİMİT	¼ ADET	20
YULAF EZMESİ	2 YEMEK KAŞIĞI	20
CORN - FLEX (Mısır gevreği)	2 YEMEK KAŞIĞI	20
MÜSLİ	2 YEMEK KAŞIĞI	20

MEYVE PORSİYONU:

YİYECEKLER	1 PORSİYON ÖLÇÜSÜ	MİKTAR(g)
ELMA	1 KÜÇÜK BOY	100
PORTAKAL	1 ORTA BOY	100
MANDALİNA	2 KÜÇÜK BOY	100
GREYFURT	½ ORTA BOY	125
LİMON	1 ORTA BOY	100
TURUNÇ	1 ORTA BOY	100
MUZ	½ BÜYÜK BOY (1 KÜÇÜK BOY)	50
KİVİ	1 ORTA BOY	120
AVAKADO	½ ADET	150
ANANAS	1 İNCE DİLİM	130
AYVA	¼ ORTA BOY	80
NAR	½ KÜÇÜK BOY	80
ÜZÜM	15 İRİ TANE	80
ARMUT	1 ORTA BOY	100
YENİDÜNYA(MALTA ERİĞİ)	6 ADET	125
KAYISI	3 ADET	100
TAZE İNCİR	1 ADET	80
KİRAZ	12 ADET	75
VİŞNE	14 ADET	80
KIRMIZI ERİK	6 ADET	100
YEŞİL ERİK	10 ADET	100
DUT	15 ADET	100
ÇİLEK	12 ADET	120
ŞEFTALİ	1 ORTA BOY	100
KAVUN	1 İNCE DİLİM	200
KARPUZ	1 İNCE DİLİM	100
KURU MEYVELER
KURU KAYISI	4 ADET	20
KURU İNCİR	1 ADET	20
KURU ERİK	5 ADET	20
KURU ÜZÜM	1 YEMEK KAŞIĞI DOLUSU	20
HURMA	5 ADET	20
TAZE SIKILMIŞ - SAF MEYVE SULARI
PORTAKAL SUYU	1 ÇAY BARDAĞI	100
GREYFURT SUYU	1 ÇAY BARDAĞI	100
ELMA SUYU	1 ÇAY BARDAĞI	100
ÜZÜM SUYU	½ ÇAY BARDAĞI	50
VİŞNE SUYU	1 ÇAYBARDAĞI	100
NAR SUYU	1 ÇAY BARDAĞI	100

KALSİYUM PORSİYONU:

YİYECEKLER	1 PORSİYON ÖLÇÜSÜ	MİKTAR(g)
SÜT	1 SU BARDAĞI	200
YOĞURT	1 SU BARDAĞI	200
AYRAN	2 SU BARDAĞI	330-400
SÜZME YOĞURT	2 YEMEK KAŞIĞI	50

SEBZE PORSİYONU:

Az yağlı ve salçalı (normal) sebze yemeklerinden listede belirtilen ölçülerde tüketilebilir. Eğer sebze yemeği yoksa; her 4 kaşığı sebze yemeği yerine salatanıza 1 tatlı kaşığı sıvı yağ ilave ediniz.

Sizin Amstrad Dergisi

Google Drive Sizin Amsrad Dergisi Pdf Adresi

C++ Qt Programming

İyi bir Qt Video Listesi.

Stack ve Heap nedir?

Stack, örneğin bir derleyicide yer alan program kodlarının parantezlemelerini depolayan bellek bölümüdür. Derleyici kodu derlerken açılan parantezleri ve onun akabinde kapatılan parantezleri stack'e atar(push) ve sırayla bunları kontrollü bir şekilde tepeden aşağıya doğru(LIFO methodu doğrultusunda) stack'ten çıkarır(pop). Eğer bir eksiklik yakalanırsa derleyici demek ki parantez eksiği var der ve ona göre hata verir. Stack'in kullanımı ile alakalı bir diğer örnek ise bir programın kodunda yer alan fonksiyonların çalışma işleyişidir. Örneğin C dilinde yazılmış bir program, çalışmaya main fonksiyonunda başlar ve main fonksiyonunda biter. Main fonksiyonu içerisinde kullanılan bir başka fonksiyon çağırılırken program, fonksiyon nerede tanımlanmışsa oraya dallanır. Stack ise bu örnekte geri dönüş adresini tutma işlevini yerine getirir. Yani programın dallandığı fonksiyonun işlenmesi bittikten sonra eski yere dönüş adresi stack'te depolanır. 

Peki heap nedir? Bunu açıklamadan önce bir analojiye değinmemiz anlamamızı kolaylaştıracaktır. RAM belleği bir defter olarak düşünün. Bir yazı yazmaya başlarken defterin başından başlarız, değil mi? Program kodlarımız program çalıştırıldığında defterin(RAM'in) başından itibaren yazılmaya başlar. Stack ise defterin sonudur. Genelde defterin sonuna bazı notlar alır ve sayfa dolduktan sonra bir önceki sayfaya kayarız, değil mi? Stack de bunu yapar. Sondan başa doğru yerleştirir. Heap ise şudur: Diyelim ki masaüstündeki bir programın simgesine(kısayoluna) çift tıkladınız. Çift tıklama sonucu o programın makine kodu CPU'nun Kontrol Birimi(Control Unit'i) tarafından hard disk'ten RAM'e kopyalanır. Bu kopya veri, belleğin başından itibaren birer birer hücrelere yerleştirilir(defterin başından itibaren yazılır). Stack ise yukarıda bahsettiğimiz gibi çeşitli ilgili durumlarda verileri, belleğin en sonundaki hücrelere birer birer yerleştirir(defterin sonuna notlar alınır). Heap ise defterde yazının bittiği sayfa ile en arka sayfadaki notların bittiği yere kadarki olan kısma denir. Bir başka şekilde ifade edecek olursak heap, program kodları ile stack'in arasında kalan yere denir. 

Stack ile heap arasındaki farka gelecek olursak bunların birinci farkı bellekte farklı yerleri ifade ediyor olmalarıdır. İkinci farkı ise şudur ki heap, stack'ten farklı bir kullanım amacına sahiptir. O da bir programın çalıştığı sıralar bellekten yer talep edildiği durumlarda talebin heap'ten isteniyor olmasıdır. Yani heap'e aslında dinamik bellektir diyebiliriz. Anlamadığınızı varsayarak yine bir örnek ile açıklamaya çalışayım: C'de listelerle alakalı bir program yazdığınızı düşünün. Ve programın algoritmasını kullanıcının girdiği sayı oranında liste düğümü olacak şekilde ayarladığınızı varsayın. Bu durumda program çalışırken kullanıcının girdiği sayı kadar malloc() fonksiyonu çalıştırılacak ve o kadar bellek alanı talebinde bulunulacaktır. İşte bu talepler sonucu cevap olarak dönen alan tahsisinin yapıldığı yer heap'tir. Heap'in zaman zaman dinamik bellek olarak adlandırılmasının nedeni de budur. Stack de istif bellek olarak adlandırılabilir. 

Bu kavramların anlaşılması yazdığımız kodun arka planda neler yaptığı hakkında bize bilgiler verir. Stack ve Heap ‘i açıklarken belleğin nasıl yönetildiği, nasıl kullanıldığı hakkında fikir edinmiş olacağız.

Stack belleği uzun bir kutu şeklinde düşünebiliriz. Yeni bir nesne eklemek istediğimizde, bu nesne en üstte olacak şekilde sıralanır. En alttaki nesneye ulaşmak için en üstteki nesneleri tek tek çıkarmamız gerekir. Basittir.

Heap belleği ise geniş bir oda şeklinde düşünelim. Boş bulduğumuz her yere bir nesne yerleştirebiliriz ve istediğimiz bir nesneyi de istediğimiz anda alabiliriz. Tabiki geniş bir odada istediğimiz nesneyi aramak vakit alan bir işlemdir. Komplekstir.

Aradaki farklara maddeler halinde göz atacak olursak:

Stack

• LIFO prensibine göre çalışır. (Last In First Out). Yani son gelen ilk olarak çıkar. Bunu bir kutu gibi düşünmüştük. Kutuya bir kitap eklemek istediğimizde en üste ekleriz. Kutudan bir kitap çıkarmak istiyorsak en üstteki kitabı alıp çıkarırız. En alttaki kitabı çıkarmak için bütün kitapları tek tek çıkarmamız lazım.
• Her bir thread (iş parçacığı) için bir tane stack bellek oluşturulur.
• Maksimum boyutu thread oluşturulurken ayarlanır.
• Stack, daha hızlıdır. Çünkü çalışma prensibi çok basittir ve ulaşılmak istenen veriler ve boş alanlar ardarda sıralanmış olur.
• Bu kısımda oluşturulmuş veriler için pointer kullanımına gerek yoktur.
• Lokal değişkenler ve metotlar bu kısıma bağlıdır.

Heap

• İçindekiler karışık bir şekilde sıralanmıştır. Bunu da oda gibi düşünmüştük.
• Heap bellek, uygulama başlatıldığında başlar. Ortak olarak kullanılır. Stack gibi her bir thread için ayrı bir tane oluşturulmaz. Bir process için bir heap oluşturulur diyebiliriz.
• Stack belleğe göre daha yavaştır. Nedeni ise herhangi bir nesneye ulaşmak için kompleks bir arama yapmanız gerekir. Bir nesneyi boş bulduğumuz herhangi bir yere koyabiliriz. Karmaşıktır.
• “Memory Leaks” , “Fragmentation” bu kısımda ortaya çıkar.
• Yer sorunu olduğu zaman işletim sisteminden daha fazla yer isteyebilir. Yani genişleyebilir.
• · Instance değişkenleri ve objeler bu bölgeye bağlıdır.

C'de Dinamik Bellek Yönetimi - Malloc - Calloc - Realloc

Dinamik Bellek Yönetimi Fonksiyonları

Standart olarak

• Malloc
• Calloc
• Realloc
• Free

fonksiyonları en çok kullanılan dby(dinamik bellek yönetimi) fonksiyonlarıdır. Bunların dışında sistem bağımlı dby fonksiyonlarıda bulunmaktadır.

Malloc

En çok kullanılan dby fonksiyonudur.

Malloc fonksiyonu programın çalışma zamanı sırasında (Run-Time) belleğin güvenli bir bölgesinden istenilen uzunluk kadar yer tahsis etmektedir. Geriye bir değer döndürür ve bu değer ayırdığı bellek bölgesinin başlangıç adresine işaret etmektedir. Eğer bellekten tahsisat yapamazsa geriye 0 değerini döndürür.

char *p;
p = malloc(5);

Bu ifade ile bellekte 5 byte boyutunda sürekli bir alan tahsis edilecektir ve tahsis edilen alanın başlangıç adresi p pointerına atanacaktır.

Bellekten yer ayırma işleminin başarısını kontrol etmek isterseniz aşağıdaki gibi bir yol izleyebilirsiniz.

char *p;
p = malloc(5);
if(p) printf("Tahsisat Basarili !\n");
else printf("Tahsisat Yapilamadi\n");

Burada 5 değeri yerine 99999999999999 değerini vererek yer ayrılmama durumunu da test edebilirsiniz.

Yukarıdaki örnekte pointerın tipi char olduğundan dolayı 5 elamanlı bir char bloğu ayrılmıştır fakat char yerine int kullanırsak biraz daha farklı bir senaryo olmakta :

int *p;
p = malloc(20);

Burada int tipinden 5 elemanlık bir blok tahsis edilmektedir. Bunun sebebi int veri tipinin 32 bit sistemlerde 4 byte yer kaplamasıdır. Fakat 16 bit sistemlerde veya 64 bit sistemlerde 5 elemanlı bir blok yerine 10 elemanlık veya 2 elemanlık bloklar ayrılabilir. Bunu engellemek için sizeof fonksiyonunu kullanabiliriz. Aşağıdaki örnekte bellekten ayrılan yer bütün sistemlerde 5 elemanlık bir blok olacaktır.

int *p;
p = malloc(sizeof(int)*5);

Malloc fonksiyonunun geriye bir adres döndürdüğünü söylemiştim. Bu noktada oluşturduğumuz pointerın tipi ile geriye döndürdüğümüz adresin tipinin aynı olmasına özen gösterin, yoksa derleyici uyarı verebiliyor. Eğer bilinçli bir tür dönüşümü yapmak isterseniz şu kodlar işinize yarayacaktır.

int *p;
p = (int *)malloc(sizeof(int)*5);

Bu ifade ile hem kendinizi güvene almış olursunuz hem de kodun okunurluluğunu arttırmış olursunuz.

Malloc fonksiyonu tahsis ettiği bellekteki bölgelere herhangi bir ilkdeğer atama işlemi uygulamaz. Yani bellekteki değerleri ile beraber size tahsis eder, ilkdeğer atamak size kalmış bir iştir.

Calloc

Malloc fonksiyonuna oldukça benzer bir yapısı vardır. Calloc fonksiyonu içerisine 2 parametre alır, birinci parametresiyle ikinci parametresinin çarpımı kadar (byte) bellek bölgesi ayırır. 15 elemanlı int tipinden bir blok ayırmak için aşağıdaki kodlar yeterli olacaktır.

int *p;
p = calloc(15,sizeof(int));

Calloc fonksiyonu aslında bellek tahsisatı yaparken Malloc fonksiyonunu kullanıyormuş bunu da küçük bir not olarak ekliyim.

Calloc, malloctan farklı olarak ayırdığı bellek bölgesini sıfırlamaktadır. Sıfırlama işlemini bizim için kendisi yapıyor. Aşağıdaki iki örneği inceleyiniz, ikiside bellekten 15 elemanlı bir int blok dizisi tahsis edip içini sıfırlıyor ve içeriğini ekrana basıyor.

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
int main() {
   int *p,i;
   p = malloc(sizeof(int)*15);
   for(i=0;i<15;i++) {
      p[i]=0;
      printf("Ayrilan Bolgenin %d. Elemani ---> %d\n",i+1,p[i]);
   }
   getch();
}

#include <stdio.h>
#include <stdlib.h>
#include <conio.h> 
int main() {
   int *p,i;
   p = calloc(15,sizeof(int));
   for(i=0;i<15;i++) {
      printf("Ayrilan Bolgenin %d. Elemani ---> %d\n",i+1,p[i]);
   }
   getch();
}

Realloc

Realloc fonksiyonu daha önce malloc veya calloc ile yapılmış tahsisatı genişletmek ya da daraltmakamacıyla kullanılır. İçerisine iki parametre alır, birincisi daha önce tahsis edilen bloğun başlangıç adresive ikincisi ise bloğun yeni uzunluğudur.

Realloc fonksiyonu yeni tahsisatı yaparken eğer belleğin daha önce tahsis edilmiş bloğunun yanında yer yoksa, bloğun tamamını içerikleriyle birlikte yeterli uzunluğu olan bir bölgeye taşır. Bu sebepten dolayı geriye döndürdüğü adres pointerı, daha önce malloc ya da calloc ile kullanılan adres pointerı ile aynı olmalıdır. Aşağıdaki örnekte önce 15 elemanlı bir int blok dizisi ayrılmış ve sonra realloc fonksiyonu ile 20 elemana genişletilmiştir.

int *p;
p = calloc(15,sizeof(int));   
p = realloc(p,sizeof(int)*5);

Eğer realloc bloğu genişletemezse geriye 0 değerini döndürecektir.

Bu arada realloc fonksiyonunu kullanmak için daha önce malloc ya da calloc fonksiyonunu kullanmış olmanız gerektiğini unutmayın.

Realloc fonksiyonu da malloc fonksiyonu gibi tahsis ettiği bloğa ilk değer vermez.

Yazının en başında verimli bellek yönetiminden bahsetmiştim. Bu fonksiyon ile ayırdığınız bellek bölgesini küçülttüğünüzde bloğunuz bellekte yer değiştirmiş olabilir, biraz mantıksız gelebilir ama olayın aslı çok mantıklıdır. Küçültülen bellek bölgesi, bellekte daha uygun bir yere taşındığında, meslea tam ona uygun bir uzunluktaki boşluğa taşındığında belleği tam olarak verimli kullanmış olmaz mısınız ?

Free

Free fonksiyonu verimli ve dinamik bellek kullanmayı sağlayan en önemli fonksiyonlardandır. Bu fonksiyon ile malloc ya da calloc ile daha önceden ayırdığınız bellek bölgelerini işletim sistemine iade edebilirsiniz. Parametre olarak içine daha önce ayırdığınız bellek bölgesinin başlangıç adresini göndermelisiniz.

int *p;
p = malloc(sizeof(int)*25);
free(p);

Eğer tahsis edilmiş bellek bölgesi free fonksiyonu ile geri iade edilmemişse, programın sonunda otomatik olarak boşaltılır.

C'de Sayı Türleri ve Otomatik Sayı Dönüşümleri

 Tamsayı türleri :

-----------------

signed char - 1 byte

unsigned char - 1 byte

signed short short>=char

unsigned short short>=char

signed int int>=short

unsigned int int>=short

signed long long>=int

unsigned long long>=int

2 Tamsayı sabiti int, unsigned int, long, unsigned long türlerinden

ilk uygun tür olacak şekilde belleğe yerleştirilir.

Literal Characters :

---------------------

2U Tamsayı sabiti unsigned int, unsigned long türlerinden

ilk uygun tür olacak şekilde belleğe yerleştirilir.

2L Tamsayı sabiti long, unsigned logn türlerinden

ilk uygun tür olacak şekilde belleğe yerleştirilir

2UL unsigned long

Gerçek sayı türleri (IEEE 754)

-------------------

float

double

long double

2.3 double

2.3F float

2.3L long double

2F float

2. double

2.0 double

*/

foo(12.3F);

printf("%d\n", d);

/*

Otomatik Sayı dönüşümleri (imlicit type convert)

-------------------------------------------

1. int'e yükseltme

---------------------

a. char , short türleri önce int türüne yükseltilir.

b. short<int ise signed int

c. sizeof(signed short) == sizeof(signed int) signed int

d. sizeof(unsigned short) == sizeof(unsigned int) unsigned int

----------------------------------------

2. long double <işlem> <!long double> = long double

3. <double> <işlem> <!double> = double

4. float <işlem> <tamsayı> = float

5. unsigned long <işlem> <!unsigned long & tamsayı> = unsigned long

6. signed long <işlem> <tamsayı & !long> = signed long

7. unsigned int <işlem> signed int = unsigned int

İstisna1 : sizeof(short) == sizeof(int)

<signed short> <işlem> <signed int> = unsigned int

İstisna2 : sizeof(int) == sizeof(long)

<signed int> <işlem> <signed long> = unsigned long

*/

char ch = -1;

if (ch > 100000U)

printf("Doğru\n");

else

printf("Yanlış\n");

int x1 = -23;

unsigned int y = 2;

printf("x1 = %u\n", x1);

printf("%lf",(float)(x1*y));

func();

extern int g;

g = 13;

return 0;

}