RAD Studio TDataSet

TDataSet* pTable = ...;
TADODataSet* pDataSet = dynamic_cast<TADODataSet*> (pTable);
if (pDataSet  && pDataSet->CommandType == cmdText) 
{
  OutputDebugString(pDataSet->CommandText.c_bcstr());
}

TADOQuery* pQuery= dynamic_cast<TADOQuery*> (pTable);
if (pQuery)
{
    OutputDebugString(pQuery->SQL->Text.c_bcstr());  
}

Ayrıca

OutputDebugString (pTable->Fields->Fields[n]-FieldName.c_str());

codequery aracı

Giriş

SLOC yani kod satırı saymak içindir

1. dir komutu ile cscope.files dosyasını oluşturmak için şöyle yaparız

dir /b/a/s *.cpp > cscope.files   
dir /b/a/s *.h   >> cscope.files   

dir komutunun çıktısında gereksiz satır ve sütunlar var, onları temizlemek gerekir

2. scope veri tabanını yaratmak için şöyle yaparız

cscope -cb

3. ctags veri tabanını yaratmak için şöyle yaparız

ctags --fields=+i -n -L cscope.files

4. CodeQuery tabanını yaratmak için şöyle yaparız

cqmakedb -s .\myproject.db -c cscope.out -t tags -p

5. Nihayet CodeQuery GUI aracı işle myproject.db açılabilir

std::popcount metodu - Bitleri Sayar

Giriş

Sadece unsigned types ile çalışır. Açıklaması şöyle

When applying bitwise operations, such as counting the number of set bits (popcount), on signed integers, there can be unexpected behavior due to the sign bit. Specifically, the sign bit can propagate during operations, potentially leading to incorrect results or undefined behavior. 

sigaction metodu

Örnek

Şöyle yaparız.

#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

void my_handler(int s){
           printf("Caught signal %d\n",s);
           exit(1); 

}

int main(int argc,char** argv)
{

   struct sigaction sigIntHandler;

   sigIntHandler.sa_handler = my_handler;
   sigemptyset(&sigIntHandler.sa_mask);
   sigIntHandler.sa_flags = 0;

   sigaction(SIGINT, &sigIntHandler, NULL);

   pause();

   return 0;    
}

std::views::split metodu

Giriş

Şu satırı dahil ederi

#include <iomanip>
#include <iostream>
#include <ranges>
#include <string>
#include <string_view>

Örnek - char

Şöyle yaparız

using namespace std::literals;

// returns the splitted string
auto splittedWords3 = std::views::split("one:two:three", ':');
for (const auto word : splittedWords3)
  std::cout << std::quoted(std::string_view(word));

Örnek - string

Açıklaması şöyle Yani string literal ile dikkatli olmak lazım

String literals always end with a null-terminator, so ":.:" is actually a range with the last element of \0 and a size of 4.

Since the original string does not contain such a pattern, it is not split.

Şöyle yaparız

using namespace std::literals;

// returns the original string (not splitted)
auto splittedWords1 = std::views::split("one:.:two:.:three", ":.:");
for (const auto word : splittedWords1)
  std::cout << std::quoted(std::string_view(word));
    
std::cout << std::endl;

// returns the splitted string
auto splittedWords2 = std::views::split("one:.:two:.:three", ":.:"sv);
for (const auto word : splittedWords2)
  std::cout << std::quoted(std::string_view(word));
    
std::cout << std::endl;

// returns the original string (not splitted)
auto splittedWords4 = std::views::split("one:two:three", ":");
for (const auto word : splittedWords4)
  std::cout << std::quoted(std::string_view(word));

std::empty

Giriş

std::enpty() aslında kendisine verilen container nesnesinin empty() metodunu çağırır. Metodun için şöyle

template <class C>
constexpr auto empty(const C& c) -> decltype(c.empty()); 
// (since c++17, until c++20)

template <class C>
[[nodiscard]] constexpr auto empty(const C& c) -> decltype(c.empty());
(since C++20) // (since c++20)

Öyleyse std::empty neden var ? Açıklaması şöyle. 

std::empty is useful for scenarios where a container may or may not provide a member function empty() for types providing a member function empty, std::empty provides a default implementation, but for a custom type not providing this function you can provide a function empty at namespace scope for use in templates; thanks to argument dependent lookup the function in the same namespace as the parameter will be used as fallback

Örnek

Şöyle yaparız

namespace Custom
{
  struct Container
  {
    bool m_empty;
  };

  constexpr bool empty(Container const& c) // custom implementation for our own type
  {
    return c.m_empty;
  }
}

template<class T>
void PrintEmpty(char const* containerName, T&& container)
{
  using namespace std;
  std::cout << containerName << " is " << (empty(container) ? "empty" : "not empty");
}

int main()
{
  PrintEmpty("std::vector<int>()", std::vector<int>());
  PrintEmpty("Container{}", Custom::Container{});
  PrintEmpty("Container{ true }", Custom::Container{ true });
}

K&R C - Yani Brian Kernighan and Dennis Ritchie C

Giriş

ANSI C 1989 yılında ortaya çıktı. Bundan daha önceki C türevlerinden bir tanesi de 1987 yılında ortaya çıkan K&R C. Bu türevin en önemli özelliği değişkenlerin nerede tanımlandığı. Değişkenler metodun başında tanımlanıyor.

Örnek

Şöyle yaparız

#include <stdio.h>

int add(a, b)
    int a, b;
{
  return a + b;
}

int main()
{
  printf("%d\n", add(5, 6));
}

Örnek - C89

Açıklaması şöyle

Versions of C up to and including C89 (i.e. the language version standardised in 1989; note this was the last major revision to the C standard before 1999) allowed variables to be declared only at the beginning of a scope, which forces you into the style shown in your first snippet.

Şöyle yaparız

int main()
{
  int i;
    
  for (i=0; i<10; i++)
  {
    printf("hello\n");
  }
    
  return 0;
}