Mesela char a[1025]'li ornekte veriyi yazdirmadan once char b[1025]'li baska bir fonksiyon cagirmayi deneyebilirsiniz. b’nin icerigi muhtemelen a’nin uzerine yazilacak ve ciktiya b yansiyacaktir.
Merhabalar, dediklerinize göre şöyle bir çözüm ürettim. Ancak malloc ile aldığım alanı nasıl serbest bırakabilirim? Ya da serbest bırakacaksam değişkeni scope dışında kullandıktan sonra mı serbest kılmalıyım?
include <stdio.h>
#include <stdlib.h>
int degeral(char** ptr){
char* deger = (char *)malloc(20*sizeof(char));
deger = "yazi";
*ptr = °er[0];
return 0;
}
int main(void){
char* yazi;
degeral(&yazi);
printf("\nYazi: %s", yazi);
}
malloc'un donus degerini cast etmeye (C’de) gerek yok.
sizeof(char) = 1
Ornekte deger'in degerini degistirmissiniz, malloc edilen yere isaret etmiyor.
yazi satirini strncpy(deger, "yazi", 20) gibi bir seyle degistirirseniz olur.
Evet, is bitince, mesela printf’ten sonra free(yazi) yapabilirsiniz.
Emin olmak icin malloc’tan donen pointer ile free’ye giden pointer’in degerlerini yazdirin. (%p)
Ana fonksiyonda da yaptığımız gibi allocate edilen değişkenini adresini http request fonksiyonuna gönderirsek değeri allocate edilen yere yazmış olur muyuz?
Hangi fonksiyon için konuşuyoruz netleştirelim. Alıntıladğınız kısımda sanki ben fonksiyona girdi verdikten sonra görevini yapsa dahi main fonksiyonuneq print edilen değişkene değer yüklenmediğini kastediyorum.
O satırın çalışan versiyonunu kod olarak koydum. Bir üst satırında &data ya değer yüklenmemiş derseniz kabul ama bu satırda bir hata yok aslında.
Pointer’ın adresindeki veri nedir? Burada rastgele olan verilen adresin işaret ettiği veri.
Burada pointer to pointer yapmaktan bahsettim. Yaygın olarka pointer to pointer kullanmakla ne kadar sık karşılaşılıyor?Görece size göre sık. Yani doğrudan global bir işaretçi kullanmaktan biraz daha fazlası değil mi bu?
İki farklı dosyada elimizde C gibi bir dil varsa ve namespace anahtar kelimemiz yok ise (c++) extern olmadan nasıl tüm kodda nasıl görünür yapabiliriz değişkeni?
İnitialize edilmeyen değişken? ptr ise riskdir ama sorun değil. &a dan bahsediyorsak evet. İlgili api ayrılmış bir tamponu şart koşuyor ve bu tampona yüklüyor.
Siz bu değeri ptr ye aktardığınızda ptr initialize (yükleniyor) oluyor. Buradaki tek risk, main fonksiyonunda ptr yi fonksiyonu çağırmadan yazdırmak. Bunu dışında gözden kaçırdığım bir durum mu var?
Oy oy örneklerininin çalışan kodunu koydum. Bellek ayırırsanız kod çalışır durumda denenmişi var.
Aslında özetlersek. Siz kapsamlardan (scope) ve un initialized değişkenlerden bahsettiğinizde ben de biraz baktım koda.
Yani beni endişelendiren bu söylemininizdi.
Diye düşündüm.
Vaktim olunca koda baktım. Sorun sizin söylediğiniz gibi scope larla alakalı değil. Api çağrılarını yeniden yazıp, ilk koddaki mantığa sadık kalarak denediğimde işaretçilerde/pointerlarda bir sorun göremedim.
Ben microsoft referansındaki örnek ile new ile bellek ayırdım. Standart C de bu iş malloc ile de halledilebilir. C ve C++ için microsft derleyicileri mi gcc mi tartışmaya açık.C standardı hedefse gcc, ama zaten microsoft API “shit” i kullanıyorsak microsoft derleyicisi.
Hala konu anlaşılmadı yada tereddüt oluştu ise. Aynı kodu, aynı pointerlarla pure(saf) C kodu ile yazayım, açıkcası bir gcc derleyicisi kurmaya üşendim elimin altında linux kurulu bir alet yok ve windows a da kurmayı düşünmüyorum.
Yani lifecycle, scope hikaye, olay apinin yükleyeceği data buffer ı ayrılmamış.
Merhabalar, ne kadar temiz, doğru bir çözüm olur bilemiyorum ama şöyle bir çözüm ürettim ve argüman olarak gönderilen pointerdan istediğim değeri alabiliyorum. (gcc’de sıkıntısız derleyebiliyorum):
Ne yaptıysam allocate edilmiş char değişkenini fonksiyona parametre olarak gönderemedim, ben de bu yüzden ara bir değişken kullanmaya karar verdim. Bu kodun tek sıkıntısı bellekte fazle yer kaplayıp kaplamayacağı yönünde. Tavsiyelerinizi bekliyorum.
Bir tane gcc uyumlu derleyici kurunca detaylarına bakarız. char* değişkeninizi main fonksiyonun dışına yazıp global hale getirin, ardından header dosyasında extern olarak tanımlayın bu durumda çalışır diye hatırlıyorum. Kodlar o versiyona da bakarız vakit olursa.
malloc un bir ikiz kardeşi vardır. free()
işi bittikten sonra free() ile ilgili bellek bölgesini serbest bırakabilirsiniz.
Burada alttaki ptr değişkeni başka bir scope içinde, değeri üstteki pointer’ın adresi. Initialize edilmemiş bir pointer dereference edilmiyor ama en başta da söylediğiniz gibi dangling pointer var.
Merhabalar, fonksiyondan hem http isteğinin durum kodunu almak, hem windows api hatası hem de request datasını alabilmek için struct yapısını kullanmaya karar verdim. Bilgilerinizle çok yardımcı oldunuz, teşekkür ederim. Aşağıdaki kodda yanlış yaptığım bir şey varsa söylerseniz sevinirim.
Bu zorunlu bir çözüm değil, global değişkenler çok sevilmez ama içinden çıkamadığınızda hızlı çözüm için faydalıdır.
Tabi ki sıkıntı oluşturur, şöyle ki fonksiyon iki kopyayı bellekte tutar ama bunu windows bellek yönetimi halledecektir. Zaten, fonksiyon sonlandığında kendini kaldıracaktır. Ama sizin de önlem almanız gerekir.
Buna ayrıca değineceğim.
Kendime alıntılayım.
Baktım:
Özellikle char* version_data; yı NULL a bile eşitlemedim. Nereye dalacak görelim diye.
Pointer’ı deklare ettik ama bellekte yer ayırmadık. Sorun yok.
Sonra bu pointer ı fonksiyon çağrısına parametre olarak verdik ve yine deklare etmeye devam ettik, hala bellekte yar ayırmadık.
Peki nasıl çalışacak?
DevC++ Editörünü kullandım. Eski bir gcc sürümü ile birlikte gelir. Bununla ilgili ayrıntılara girmeyeceğim pragma ile .lib dosyası ekleyebilmek varken bana elle winhttp.lib ekletti ya neyse.
Şimd dönelim server.h dosyasına. Ben yine #include lar da düzelterek, ikisini aynı klasörde çalıştırdım. Yalnız sizin, hata takip kodlarını kaldırdım siz tekrar ekleyebilirsiniz. Değişkenler gözümün önünde dursun diye.
Size baştan beri anlatmaya çalıştığım şuydu. Pointer to pointer yaparsanız, bellek ayırırken ve değerleri yüklerken bir şeyler gözden kaçırabilirsiniz.
Bu nedenle bu işi C++ daha kolay bir metodla yapar, new anahtarı ve delete anahtarı bunu hallederdi.
Ama gcc dediğinizde ve saf c kodu yazdığınızda malloc, realloc gibi bellek yönetim fonksiyonlarına başvurmanız gerekir.
Ama pointer to pointer lara malloc yaparken de dikkat etmek gerekiyor.
main fonksiyonunda pointer ı yüklemedik, sorun yok, yüklenmemiş pointer ı fonksiyondaki işaretçiye attık yine sorun yok.
Ama baştan beri söylediğim iki şey eksikti.
Birincisi, bellek ayırmadınız.
Daha önceden de main fonksiyonu içinde bellek ayırabilirdik mesela 1 karakterlik. Sonra realloc ile yeniden yeni boyuta göre yeniden bellek tahsisi yapabilirdik.
Özetlersek, pointerlarınızda sorun yok, pointerlarınızı aldıktan sonra düzgün bellek ayırmanız gerekir, henüz ayrılmamış.
Üzerine de aldığınız veriyi pointer ın gösterdiği belleğe kopyalayamamışsınız.
Ayrıca print ettikten sonra bence free ile belleği serbest bırakın. Bunun yanısıra, api referansalarana bakıp, aldığınız api handle larını serbest bırakın. Yani kodun hala toparlanacak kısımları var. Malum gece bir yarısı bakabildim onlara dokunmadım.
O bu yeni filmmiş buna henüz bakmadım.
Verdiğim kodu incelerseniz, sorununuz çözüleceğini tahmin ediyorum. Kolay gelsin.
böyle eksik bir sonuç alıyorum. Bunun aynısını internetten binary dosya indirirken de yaşıyorum. Öneriniz, tavsiyeniz nedir? İnternette do while ile yapılmış örnekler gördüm ancak daha deneyemedim.
Hangi yapıyı kullandığınızdan bağımsız olarak, ayırdığınız tampondan fazla veriyi bir seferde alamazsınız.
Bu tamponun bir sınırı vardır.
Ben şöyle düşünmüştüm. domain adında bir server’ınız var ve biz buradan version kontrolü yapıyoruz. Version farkı varsa dosyayı indiriyoruz.
Siz ise burada bir dosya varsa (binary dahil) doğrudan indiriyormuşsunuz gibi tasarlamışsınız kodunuzu.
Hani bellekte yer olsa dahi en fazla unsigned long int uzunluğu kadar byte(char için 8 bit kullanıldığını varsaydım.) veri alabilirsiniz buffer tanımınız gereği. Bunun üzerindeki bir boyutta veri çekerseniz bu şekilde kodun çalışmaması doğaldır.
Küçük bir tampon tanımlayıp,
WinHTTPReadData çağrısında,
data_size değeri sıfır olana kadar bu apiyi tekrar çağırmanız gerekir. Bunu ister while ister, for döngüsüyle isterseniz if koşulu ile kontrol ederek çağırmalısınız.
Her seferinde de de tamponu flush gibi bir komut ile sıfırlamanız ve yeniden yüklemeniz gerekir.
Peki buffer ile parça parça aldığınız bu verileri nasıl tutacaksınız?
Bana verdiğiniz kodlarda hep printf ile ekrana yazdırıyorsunuz.
meseala binary bir dosyada birden çok yerde /0 /n gibi /00 gibi karakter dizileriyle karşılaşabilirsiniz. Bunlara denk gelirse zaten printf yazmayı sonlandırır yani sonrasında veri bile olsa printf doğası gereği sıfır sonlandırımış bir dizi ile karşılaşırsa yazma işlemini durdurur.
Dönelim küçük bir tampon ile parça parça indirdiğimizi varsayalım, bunları bellekte birleştirdiğinizde mesela 3GB bir veri, devasa bir değişkene mi atayacaksınız?
Bence hem veriyi alıp aldıkça bir dosyaya yazdırmak basit bir çözüm olabilir.
Yani aynı anda birden çok farklı konuda bir arada sorularınız. Ekrana yazdırlamayacak karakterleri olan yada içinde birden çok yerde sıfır ve null ile sonlandırılmış diziler içeren verilerle çalışırken ekrana yazamayabilirsiniz.
Bunun yanı sıra tamponlarınız/bufferlarınız sınırlıdır tek seferde tüm veriyi çekemezsiniz. Haberleşme türünüze göre senkron ve asenkron haberleşem faktörlerini bir kenara bıraktım.
Öncelikle çektiğiniz büyük miktarda veriyi nerede tutacağınıza karar vermelisiniz.
Binary dosyasını ve versiyon kontrolünü Github’tan yapıyorum.
GitHub’dan maksimum 60 mb boyutlarında zip dosyası indiriyorum. Bu yüzden pek sıkıntı olacağını sanmıyorum. O kadar devasa olmasa da allocate edilen değişkene bu yeni gelen verileri yazmak için değişkeni reallocate mi etmeliyim?
Request atarken gelen verinin boyutunu da kontrol ediyorum zaten. Denediğim kadarıyla tamponda maksimum 2000 karakter alabiliyorum.
Uygulama senkron çalışacak. İlk önce programın kurulu olup olmadığını kontrol edecek. Kuruluysa programın güncellemesini denetleyecek, kurulu değilse programı bilgisayara kuracak.
Bir tane do while döngüsü ile denemiştim, ancak data_size değişkeni veri gelmemesine her zaman sabit bir değer döndürüyordu. Bufferı mı data_size’ı mı sıfırlamalıyım?
Ben kod yapısı olarak zaten çok büyük olmadığı için tüm veriyi alıp ondan sonra dosyaya yazmayı düşünmüştüm.
Dinamik allocate edilmis char pointer’indan mi bahsediyoruz?
char *ptr = malloc(42);
func(ptr);
Allocate edilmis char degiskeni soyle:
char c = 'x';
func2(c);
Bu bahsedilen basarisiz denemelerin kaydi var mi? Kod uzerinden gidelim.
Bunun yerine neden dogrudan WinHttpReadData(data, data_size) yapmiyoruz?
Hayir, nasil bir sikinti vardi aklinizda?
Ama dedigim gibi, gerek de yok.
Oncelikle dedigim gibi cast kullanilmis.
Ikinci olarak sadece pointer boyu kadar yer ayriliyor. Sonra buna strlen(ptr)+1 kadar byte yaziliyor. strlen(ptr)+1 > sizeof(ptr) (tipik olarak 4 veya 8) ise buffer overflow olur.
Program kapanana kadar Windows bellek yonetimi devreye girmiyor. C bellek yonetimi tmp_data_buf’in free edilecegini garantiliyor. malloc ile alinan alan kaliyor/leak ediyor.
Burada fonksiyonun basarili olup olmadigina bakilmadan data_size kullanilmis.
Burada fonksiyonun sonucuna bakmiyoruz.
Burada bir pointer kadar yer ayiriyoruz? data_size+1 > sizeof(char *) (>~ 4 veya 8) ise sikinti olur.
Fonksiyon dokumentasyonu bu konuda ne diyor?
0 byte donene kadar loop’la diyordu sanki. @semtex de aynisini soyledi.
O bir yontem.
Bir kerede atiyorum 128 MiB allocate edip surekli icine okumak da baska bir yontem.
Cagrilan fonksiyonun limitasyonu olabilir.
Kodu gorelim mi?
Hic bir seyi sifirlamaya gerek yok, ReadData’nin yazdigini soyledigi seyleri okuyoruz zaten, eski degerleri kimsenin umrunda degil.
Gerek olmadığını ben de biliyorum ancak kullandığım derleyiciden mi (gcc) yoksa derleyicinin başka bir özelliğinden mi değişken türü ile ilgili uyarı verdiği için bir türlü WinHttpReadData’ya allocate edilmiş değişkenin adresini gönderemedim.
char* data = (char *)malloc((data_size+1)*sizeof(char))
WinHttpReadData(server_request, data, data_size, &data_size)
Bu da aynı şekilde, derleyici cast kullanılmayınca derleyici ya uyarı veriyor derlemeye devam ediyordu yahut direkt hata verip derlemeyi durduruyor diye cast kullanmıştım.
Büyük bir veri geldiği zaman (4gb gibi mesela) aynı anda iki farklı kopyası farklı adreslerde saklanacağı için scope bitene kadar performans sorunu olur diye düşünmüştüm.
Maalesef kodu sildim, bir şey deneyip burada paylaşırım.
Cast kullanmama sebebimiz tam olarak bu. Dogru header’lari include etmediysek veya C++ derliyorsak bu hatayi maskeliyor.
Daha beteri, bir tanesi stack’te tutuluyor. C standardinin disinda konusuyorum, fakat pratikte foo bar[baz] seklinde deklare ettigimiz seyler 1-2 MiB’in ustune cikamaz. C sanirim 65k eleman filan garantiliyordu minimum.
Aynı şeyleri yapıp bu sefer hata yahut uyarısız derlemeyi nasıl başarabildim bilmiyorum ancak bu sefer kod sıkıntısız çalışıyor (Eksik veri vermesi dışında). Gelen tüm verileri çekmek için şöyle bir şey denedim:
Bu kod sıkıntısız çalışıyor ancak tam olarak anlamadığım bir şekilde (Not: Fark ettiğim kadarıyla bir adres değeri olmalı) bir değer arrayın başına ekleniyor. O değerden nasıl kurtulabilirim? Yoksa tamamen yanlış bir şey mi yapıyorum?
