So, I've been tinkering with programming for quite a while now. I've been through at least four introductory courses after teaching programming to myself on the calculator, and eventually moved on to Computer "programming" with HTML and CSS. Later, I accidentally (yes, you've read that correctly) learned PHP. I was stuck there for quite some time, and because server side only programming sucks, I learned JavaScript. But I have a problem: Those are all not a language of choice for an application outside of the web, and the web is not the direction I am planning to take.
Now, I did try a few computer languages. I had a go at C++ self-teaching ages ago, but I failed. I was recommended Python at Cemetech, but honestly, that didn't quite "sit" too. But a few months ago, I had a 1-week school internship, and apparently I applied to the correct department, because they gave me a book and a C++ crash-course. But so far all I did was either JavaScript or console applications.

So I figured "what if I try to teach myself how to make Windows Desktop applications?". Great, isn't it? Well, and then I opened a new, empty "C++ Desktop Application" project in Visual Studio. And I got this:
Code:
// WindowsGUITest.cpp : Defines the entry point for the application.
//

#include "stdafx.h"
#include "WindowsGUITest.h"

#define MAX_LOADSTRING 100

// Global Variables:
HINSTANCE hInst;                                // current instance
WCHAR szTitle[MAX_LOADSTRING];                  // The title bar text
WCHAR szWindowClass[MAX_LOADSTRING];            // the main window class name

// Forward declarations of functions included in this code module:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);

int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPWSTR    lpCmdLine,
                     _In_ int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);

    // TODO: Place code here.

    // Initialize global strings
    LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadStringW(hInstance, IDC_WINDOWSGUITEST, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);

    // Perform application initialization:
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }

    HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_WINDOWSGUITEST));

    MSG msg;

    // Main message loop:
    while (GetMessage(&msg, nullptr, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }

    return (int) msg.wParam;
}



//
//  FUNCTION: MyRegisterClass()
//
//  PURPOSE: Registers the window class.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEXW wcex;

    wcex.cbSize = sizeof(WNDCLASSEX);

    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_WINDOWSGUITEST));
    wcex.hCursor        = LoadCursor(nullptr, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = MAKEINTRESOURCEW(IDC_WINDOWSGUITEST);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

    return RegisterClassExW(&wcex);
}

//
//   FUNCTION: InitInstance(HINSTANCE, int)
//
//   PURPOSE: Saves instance handle and creates main window
//
//   COMMENTS:
//
//        In this function, we save the instance handle in a global variable and
//        create and display the main program window.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   hInst = hInstance; // Store instance handle in our global variable

   HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, hInstance, nullptr);

   if (!hWnd)
   {
      return FALSE;
   }

   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);

   return TRUE;
}

//
//  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE:  Processes messages for the main window.
//
//  WM_COMMAND  - process the application menu
//  WM_PAINT    - Paint the main window
//  WM_DESTROY  - post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_COMMAND:
        {
            int wmId = LOWORD(wParam);
            // Parse the menu selections:
            switch (wmId)
            {
            case IDM_ABOUT:
                DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
                break;
            case IDM_EXIT:
                DestroyWindow(hWnd);
                break;
            default:
                return DefWindowProc(hWnd, message, wParam, lParam);
            }
        }
        break;
    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint(hWnd, &ps);
            // TODO: Add any drawing code that uses hdc here...
            EndPaint(hWnd, &ps);
        }
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

// Message handler for about box.
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    UNREFERENCED_PARAMETER(lParam);
    switch (message)
    {
    case WM_INITDIALOG:
        return (INT_PTR)TRUE;

    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, LOWORD(wParam));
            return (INT_PTR)TRUE;
        }
        break;
    }
    return (INT_PTR)FALSE;
}


I have absolutely no idea what this does... Confused I tried to search the web for good tutorials for this kind of thing, but none of the codes would compile in VS2017. Now, my question is, could anyone either link me to some tutorial they have tried or were recommended, or even get me started themselves? Are there any specific keywords I may have missed in my Google searches?

I intend to post my first one or two projects here, provided I manage to do anything.
This is why you don't program Microsoft specific; the source always just looks like a mess. I would highly recommend you use something like Qt or another cross compatible tool.
You'll have a bad time with straight C-based Win32 API's. There are tons of edge cases and "special knowledge" you'll find buried in function API's.

I recommend doing something easier and cross platform like Mateo said. If you like C#, Eto.Forms isn't bad, you don't have to bundle any additional binaries or libs with that API.
Welcome to non-.NET Windows programming! Over the decades, the gunk has piled on the Win32 API, resulting in its unanimous disuse in this day and age.

You are probably looking for C++/CLI. It has the "simplicity" of .NET, but for the most part keeps the syntax of C++, save for some special added syntax like the caret, which represents a .NET-managed pointer. However, if you are not interested in WinForms or WPF, you also have the choice of other UI toolkits, such as WxWidgets and Qt, which use pure C++.

For desktop programming, you also have the "cool and hip" choices like Electron, which is basically an excuse to turn your program into a web browser, and then make a web application in JavaScript that integrates tightly with the system.
As others have said, programming specifically for Windows becomes a mess. I can't recommend any specific C++ tutorials, since I work mostly in C right now, but this one seems to be pretty thorough. If you want one that I can personally vouch for, learn-c.org is the resource I used to start C programming. Note that there are minor differences between C and C++, but learning the basics like variables, arrays, and pointers are all there. Note that with C++, strings have been overhauled, but still exist in their C implementation as "C-Strings".

As for IDEs, I personally don't recommend Microsoft's Visual Studio, although it's built in, has some problems I was never fond of. I use Code::Blocks personally, sometimes also using Notepad++ (which I believe to be one of the best general text editors for people who never learned Vim). However, it's down to personal preference what you used. My first "IDE" was really a build script I wrote to copy a C file to a build directory, assemble with GCC, then automatically launch. It really depends on if you're a fan of highly functional, highly customizable, or highly open-source IDEs, which one you'll choose.

I recommend using C++ standards or third party libraries for file I/O, graphics, and anything above basic arithmetic. Stuff like OpenGL or SDL for graphics work wonders, although personally I can only vouch for SDL, given I haven't tried any OpenGL yet. For file I/O, I've found that writing your own functions to read/write/append to files is probably the most fun way to handle that stuff, however lots of third-party libraries exist to make it pretty easy for you.

Strangely, most of the time (at least in my field of familiarity), I find that cross-platform APIs are actually more simple to write than platform-specific ones, ESPECIALLY Windows-specific programming. You can use cross-platform C/C++ standard functions like fopen() to much greater effect than any Windows-specific variant. Not everything will be simple to make cross-platform, but I find it a good exercise, one that helps you to dig deeper and understand more about the C family's implementations.
I would recommend being very fluent in C++ before delving into any of the APIs. Otherwise, they will appear incomprehensible.
Just to throw my 2 cents in.. I've used Microsoft development tools over the years (VB6 for a period, then switching over to Visual Studio for VB, C++ and C#). I self-taught myself enough C# to build a few level editors, etc. and never learnt the intricacies of the development environment or language. But - times have changed, and there are a lot more options out there these days. Ongoing I'll be looking at Qt or something similar to get back into C++ and cross-platform compatibility.

Back when I learnt C++, it was out of a much earlier edition of this book.
  
Register to Join the Conversation
Have your own thoughts to add to this or any other topic? Want to ask a question, offer a suggestion, share your own programs and projects, upload a file to the file archives, get help with calculator and computer programming, or simply chat with like-minded coders and tech and calculator enthusiasts via the site-wide AJAX SAX widget? Registration for a free Cemetech account only takes a minute.

» Go to Registration page
Page 1 of 1
» All times are UTC - 5 Hours
 
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum

 

Advertisement