18 Ocak 2021 Pazartesi

valgrind mem-check aracı

Giriş
Heap bilgilerini gösterir

gdb
memcheck ile gdb'yi beraber kullanmak için şöyle yaparız.
valgrind --vgdb=yes --vgdb-error=0 app
Örnek
Şöyle yaparız.
valgrind --tool=memcheck ./myprogram 4
Bu komut sonund HEAP SUMMARY çıktısına bakılır. 

total heap usage satırında toplam kaç tane alloc ve kaç tane free yapıldığı görülebilir. X bytes allocated bilgisi de heap'ten toplam ne kadar bellek kullanıldığını gösterir. 

Örnek
Elimizde şöyle bir kod olsunn
#include <fstream>

int main(int, char**) {
    std::ifstream ww15mgh("ww15mgh.grd");
    double value;
    while (ww15mgh >> value);
    return 0;
}
Bu kodu çalıştıralım. 1 milyon defa alloc ve 1 milyon defa free yapılmış, ve tüm alloc'ların toplamı  59,302,487 byte.
$ g++ stackoverflow.cpp
$ valgrind --tool=memcheck --leak-check=yes ./a.out 2>&1 | grep total
==523661==   total heap usage: 1,038,970 allocs, 1,038,970 frees, 59,302,487 
Açıklaması şöyle
The number 59,302,487 shown by valgrind is the sum of all allocations, and does not represent the actual memory consumption of the program.
Şimdi aynı kodu biraz değiştirelim ve şöyle yapalım
#include <fstream>
#include <string>
#include <cstdio>

int main(int, char**) {
    std::ifstream ww15mgh("ww15mgh.grd");
    double value;
    std::string text;
    while (ww15mgh >> text)
        std::sscanf(text.c_str(), "%lf", &value);
    return 0;
}
$ g++ stackoverflow2.cpp
$ valgrind --tool=memcheck --leak-check=yes ./a.out 2>&1 | grep total
==534531==   total heap usage: 3 allocs, 3 frees, 81,368 bytes allocated
3 defa alloc ve 3 defa free yapılıyor. Tüm alloc'ların toplamı 81,368 byte.

11 Ocak 2021 Pazartesi

std::is_pointer_interconvertible_with_class

Örnek
Şöyle yaparız
struct A { int a; };
struct B { int b; };
struct C: public A, public B { };

// The following will succeed because, despite its appearance,
// &C::b has type "pointer to member of B of type int"
static_assert(is_pointer_interconvertible_with_class( &C::b ));

modff metodu - Floating Point Sayısı Integral ve Fractional Kısımlara Böler

Giriş
Şu satırı dahil ederiz
#include <math.h>
İmzası şöyle
float modff( float arg, float* iptr );
Açıklaması şöyle
Decomposes given floating point value arg into integral and fractional parts, each having the same type and sign as arg. The integral part (in floating-point format) is stored in the object pointed to by iptr.

CMake

Örnek - Windows C Projesi
Şöyle yaparız
cmake_minimum_required(VERSION 3.13)
project(wintimertest C)
set(CMAKE_C_STANDARD 11)
add_executable(wintimertest main.c)
target_link_librariries(wintimertest winm.lib)

4 Ocak 2021 Pazartesi

Rule Of 3

Giriş 
Rule of 3 şudur
If you need to explicitly declare either the destructor, copy constructor or copy assignment operator yourself, you probably need to explicitly declare all three of them.
Eğer sınıf belleği silmek için destructor yazmaya ihtiyaç duyuyorsa, muhtemelen copy constructor ve assignment operator'ünü de yazmaya ihtiyaç duyar der.

Rule of Zero İle İlişkisi
Mümkünse Rule of Zero tercih edilmeli. Açıklaması şöyle
The full name of the rule is the rule of 3/5/0.

It doesn't say "always provide all five". It says that you have to either provide the three, the five, or none of them.

Indeed, more often than not the smartest move is to not provide any of the five. But you can't do that if you're writing your own container, smart pointer, or a RAII wrapper around some resource.
Örnek
Elimizde şöyle bir kod olsun
// RAII Class which allocates memory on the heap.
class ResourceManager {
  Resource* resource;
  ResourceManager() {resource = new Resource;}
  // In this class you need all the destructors/ copy ctor/ move ctor etc...
  // I haven't written them as they are trivial to implement
};
Bu kodu rahatlıkla şöyle yaparız. Bu durumda destructor, copy constructor ve copy assignment yazmaya gerek kalmaz
class ResourceManager {
    std::unique_ptr<Resource> resource;
};




std::iterator - Kullanmayın

Giriş
Bu sınıf ata sınıf olarak kullanılmak üzere tasarlanmıştır. C++17 ile deprecate ediliyor.