ZFX + Developia

Code: Alles auswählen

#ifndef INCLUDED_WIN32_WINDOW_CLASS
#define INCLUDED_WIN32_WINDOW_CLASS

#pragma once

#include "WindowHandle.h"


namespace Win32
{
  template <class T, LRESULT (T::*WndProc)(HWND, UINT, WPARAM, LPARAM)>
  class WindowClass
  {
  private:
    ATOM cls;

    static LRESULT CALLBACK BootstrapWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
    {
      if (msg == WM_CREATE)
      {
        T* obj = static_cast<T*>(reinterpret_cast<CREATESTRUCT*>(lParam)->lpCreateParams);
        SetWindowLongPtr(hWnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(obj));
        SetWindowLongPtr(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(&WndProcThunk));
        return (obj->*WndProc)(hWnd, msg, wParam, lParam);
      }

      return DefWindowProc(hWnd, msg, wParam, lParam);
    }

    static LRESULT CALLBACK WndProcThunk(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
    {
      T* obj = reinterpret_cast<T*>(GetWindowLongPtr(hWnd, GWLP_USERDATA));
      return (obj->*WndProc)(hWnd, msg, wParam, lParam);
    }

  public:    
    WindowClass(LPCWSTR lpszClassName,
                UINT style,
                HICON hIcon,
                HICON hIconSm,
                HCURSOR hCursor,
                HBRUSH hbrBackground = (HBRUSH)(COLOR_WINDOW + 1),
                LPCTSTR lpszMenuName = nullptr)
    {
      WNDCLASSEXW wnd_cls;
      wnd_cls.cbSize = sizeof(wnd_cls);
      wnd_cls.style = style;
      wnd_cls.lpfnWndProc = &BootstrapWndProc;
      wnd_cls.cbClsExtra = 0;
      wnd_cls.cbWndExtra = 0;
      wnd_cls.hInstance = GetModuleHandleW(nullptr);
      wnd_cls.hIcon = hIcon;
      wnd_cls.hCursor = hCursor;
      wnd_cls.hbrBackground = hbrBackground;
      wnd_cls.lpszMenuName = lpszMenuName;
      wnd_cls.lpszClassName = lpszClassName;
      wnd_cls.hIconSm = hIconSm;
      cls = RegisterClassExW(&wnd_cls);
    }

    ~WindowClass()
    {
      UnregisterClassW(reinterpret_cast<LPCWSTR>(cls), GetModuleHandleW(nullptr));
    }

    WindowHandle createWindow(T& obj,
                              DWORD dwExStyle,
                              LPCWSTR lpWindowName,
                              DWORD dwStyle,
                              int X = CW_USEDEFAULT,
                              int Y = CW_USEDEFAULT,
                              int nWidth = CW_USEDEFAULT,
                              int nHeight = CW_USEDEFAULT,
                              HWND hWndParent = 0,
                              HMENU hMenu = 0)
    {
      return WindowHandle(CreateWindowExW(dwExStyle,
                                          reinterpret_cast<LPCWSTR>(cls),
                                          lpWindowName,
                                          dwStyle,
                                          X,
                                          Y,
                                          nWidth,
                                          nHeight,
                                          hWndParent,
                                          hMenu,
                                          GetModuleHandleW(nullptr),
                                          &obj));
    }

  };
}

#endif  // INCLUDED_WIN32_WINDOW_CLASS

Code: Alles auswählen

const char* static blub = "abc";  // OK
const char* blab = blub;  // OK
const char* static blob = blab;  // error

Code: Alles auswählen

void foo()
{
   char name[] = "foo";
   use(name); // OK
   store(name); // error: object lifetime too short
   store("foo"); // OK
}

const char *storedName;

void use(const char *name)
{
   storedName = name; // error: object lifetime unspecified
}

void store(const char *extern name)
{
   storedName = name; // OK
}

Code: Alles auswählen

local int x;  // OK
local int* local px = &x;  // OK
int** blub = new int*;
*blub = &px;  // error

Code: Alles auswählen

void f()
{
  int x;
  int* px = &x;  // px is implicitly declared int auto* px, deduced to int local* px
  int** blub = new int*;  // blub is implicitly declared int * auto * blub, deduced to int * dynamic * blub
  *blub = px;  // error: px is of type int local*, *blub is of type int dynamic*
}

Code: Alles auswählen

void f()
{
  static int x;
  int* x = new int;  // OK, new int returns int dynamic*, can be converted to int*
  int* y = &x;  // OK, &x is int static*, can be converted to int*

  int a;
  int* z = &a;  // error, can't convert int local* to int*
}

Code: Alles auswählen

struct A
{
   int *p;
};

A g; // g global => p hat Typ int *extern

void foo()
{
   int i;
   A a; // a lokal => p hat Typ int *local
   a.p = &i; // OK
   foo(a); // OK

   g.p = &i; // error
   foo(g); // OK

   A &r = a; // Referenz lokal
   r.p = &i; // OK
   foo(r); // OK

   extern A b; // b extern => p hat Typ int *extern
   b.p = &i; // error
   foo(b); // OK
}

void bar(A &a)
{
   int j;
   a.p = &j; // error: _Parameter_-Referenz auf a NICHT mehr lokal => p hat Typ int *extern?!
   int *p = a.p; // error: p hat Typ int *local?! 
   // a.p hat einen Zwischentyp, nämlich Referenz auf externes int*local, also int *extern local
}

Code: Alles auswählen

int* g;

void f()
{
  int x;
  int** y = new int*;  // OK, int* auto* can be assigned int* dynamic*
  int* px = &x;  // OK, int auto* can be assigned int local*
  *y = &x;  // error, int* can't be assigned int local*
  *y = px;  // error, int* can't be assigned int auto*
  px = *y;  // OK, int auto* can be assigned int*
  g = px;  // error, int* can't be assigned int auto*
  px = g;  // OK, int auto* can be assigned int*
}

// second level auto is implicitly declared on local variables, top level auto/storage class qualifier is ignored just like with function signatures

Code: Alles auswählen

int* g;
int** h = &g;  // OK, int* static* can be converted to int**

void f()
{
  int x;
  int* px = &x;  // OK, no conversion necessary
  int** y = new int*;  // OK, int** can be converted to int* local*
  *y = &x;  // error, int local* can't be converted to int*
  *y = px;  // error, int local* can't be converted to int*
  px = *y;  // OK, int* can be converted to int local*
  g = px;  // error, int local* can't be converted to int static*
  px = g;  // OK, int static* can be converted to int local*
  *y = g;  // OK, no conversion necessary
  y = &g;  // OK, int* static* can be converted to int* local*
  g = *y;  // OK, int* can be converted to int static*
}