Understanding std::rotate

While working on the future version of my C++20 WinDlg library, I stumbled upon the need to shift characters within a string. My first impulse was to use memmove, but hey, there should be a C++ way to do this.

In fact, std::rotate seemed to be the appropriate fit – safe and sound –, but turns out I had a different idea on how it would work, and it took me a while to properly understand it. The central idea is: you take the interval [it1 it2) and move it right, so it will end at it3). Everything beyond it3 will be placed at the beginning. Thus it actually “rotates” to the left.

Examples:

std::wstring s = L"01234";

std::rotate(s.begin(), s.begin() + 1, s.end()); // 12340
std::rotate(s.begin(), s.begin() + 2, s.end()); // 23401
std::rotate(s.begin(), s.begin() + 4, s.end()); // 40123

std::rotate(s.begin() + 1, s.begin() + 2, s.end()); // 02341
std::rotate(s.begin() + 3, s.begin() + 4, s.end()); // 01243

Reusing code in const and non-const methods, C++17

I found the code below from this great answer in StackOverflow. It allows you to implement the const method with your logic, then use this one-liner to implement the non-const method. It’s a trick from the great Scott Meyers:

const T& f() const {
	return something_complicated();
}

T& f() {
	return const_cast<T&>(std::as_const(*this).f());
}

I’m using this thing everywhere.

Project templates in Visual Studio 2022

After configuring C and C++ projects countless times, base on these settings, I finally bit the bullet and created a reusable template in Visual Studio 2022. And it’s surprisingly simple: create the project and then go Project → Export Template.

The project name itself can be used inside files with $safeprojectname$ string. In order to have it replaced even inside .rc files, edit the .vstemplate and add:

<TemplateContent>
  <Project TargetFileName="ayylmao.vcxproj" File="ayylmao.vcxproj" ReplaceParameters="true">
    <ProjectItem ReplaceParameters="true">RES\$safeprojectname$.rc</ProjectItem>
  </Project>
</TemplateContent>

There’s no GUI for deleting a template, though. One must manually remove the zip files from two different locations:

• Documents \ My Exported Templates
• Documents \ Templates \ Project Templates

To restore a template, simply copy the zip back to:

• Documents \ Templates \ Project Templates

Windows 10 SDK 10.0.20348.0 is gone

I was caught by surprise today after updating Visual Studio 2022 to version 17.14.11. All my projects failed to compile, because the SDK files disappeared. I first thought something broke with VS Code support, but then I saw that Visual Studio itself had the same problem.

Turns out the Windows SDK I was using – 10.0.20348.0 – was simply deprecated and removed in this update, according to here, and the release note itself. Indeed, Visual Studio Installer won’t show it anymore.

Apparently, now I’ll have to install a Windows 11 SDK, even if I’m running Windows 10. I hope this doesn’t break my stuff.

Non-movable and non-copyable C++20 classes

On my fantastic journey implementing WinLamb v2, I’m diving deep into C++20, grasping a lot of concepts I never understood before, and having a lot of fun along the way.

One of the things that I implemented was the idea of non-copyable and non-movable classes, at first, using macros. This felt inelegant, so I implemented P2895 paper with utility classes. It ultimately failed with the nested ListView classes, so I discarded the idea too.

My final solution was to = delete move constructor, which will prevent all copy and move. The hard rules are not particularly easy to memorize, so I’ll let them here for further reference:

1. The two copy operations are independent. Declaring copy constructor does not prevent compiler to generate copy assignment and vice versa. (Same as in C++98.)
2. Move operations are not independent. Declaring either one of them prevents the compiler to generate the other. (Different from copy operations.)
3. If any of the copy operations is declared, then none of the move operations will be generated.
4. If any of the move operations is declared, then none of the copy operations will be generated.
5. If a destructor is declared, then none of the move operations will be generated. Copy operations are still generated for reverse compatibility with C++98.
6. Default constructor generated only when no constructor is declared. (Same as in C++98.)

Example:

class Foo {
private:
	Foo(Foo&&) = delete; // non-copyable, non-movable
};

Using VSCode for C++ projects

For a long time I thought I only could use Visual Studio to write C++ programs on Windows, because MSVC toolchain requires some particular initializations before being able to run.

Turns out there is a way to smoothly run all the MSVC machinery from within VSCode. The answer is the same I found last year in automating MSVC builds: we need a .bat file to call MSVC’s own .bat, then we invoke VSCode executable right after.

@echo off
setlocal

for /f "usebackq delims=" %%i in (`
	"%programfiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" ^
	-latest ^
	-property installationPath
`) do set VSBUILDROOT=%%i

if not defined VSBUILDROOT (
	echo Visual Studio not found.
	exit /b 1
)

call "%VSBUILDROOT%\VC\Auxiliary\Build\vcvars64.bat"
"%localappdata%\Microsoft Visual Studio Code\Code.exe"

The script above uses vswhere to locate vcvars64.bat for any Visual Studio version. Save this .bat somewhere, and put a shortcut to it in your start menu, naming it “VSCode MSVC” or something like that.

To my surprise, multiple things work better in VSCode than in Visual Studio itself:

• file navigation;
• file creation and deletion;
• code and comment folding;
• keyboard shortcuts;
• error reporting – VSCode highlights in red the files with errors, while in Visual Studio I have to build the project and look at the output to see which files are broken.

Automating MSVC builds

While rewritting a few of my personal tools from Rust back to C++, I found myself willing to automate the build process. At first, I tried to invoke MSVC’s cl compiler directly, but it has proven to be absolute hell to do.

Eventually I stumbled upon the marvellous MSBuild tool, which is capable of understanding the .sln file and take all compiler and linker options from it:

msbuild foo.sln /p:Configuration=Release /p:Platform=x64

With that, I could leverage vswhere to locate vcvars64.bat for any Visual Studio version, then write the script to automate one build:

@echo off
setlocal

for /f "usebackq delims=" %%i in (`
	"%programfiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" ^
	-latest ^
	-property installationPath
`) do set VSBUILDROOT=%%i

if not defined VSBUILDROOT (
	echo Visual Studio not found.
	exit /b 1
)

call "%VSBUILDROOT%\VC\Auxiliary\Build\vcvars64.bat"

set APP="id3-fit"
msbuild %APP%.sln /p:Configuration=Release /p:Platform=x64
move /Y x64_Release\%APP%.exe "D:\Stuff\apps\_audio tools\"
rmdir /S /Q x64_Release
pause

Finally, it was time to automate the release build of all my listed projects:

@echo off
setlocal

for /f "usebackq delims=" %%i in (`
	"%programfiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" ^
	-latest ^
	-property installationPath
`) do set VSBUILDROOT=%%i

if not defined VSBUILDROOT (
	echo Visual Studio not found.
	exit /b 1
)

call "%VSBUILDROOT%\VC\Auxiliary\Build\vcvars64.bat"
if errorlevel 1 exit /b 1

call :Deploy "id3-fit"      || exit /b 1
call :Deploy "sync-folders" || exit /b 1
call :Deploy "yt-dl"        || exit /b 1

pause
exit /b 0

:Deploy
	cd .\%~1
	msbuild %~1.slnx /p:Configuration=Release /p:Platform=x64
	if errorlevel 1 (
		echo Build failed: %~1
		cd ..
		pause
		exit /b 1
	)
	move /Y x64_Release\%~1.exe .\
	rmdir /S /Q x64_Release
	cd ..
	exit /b 0

The main point is that :Deploy is a subroutine – or a function –, with %~1 being the first argument, and exit /b being the return statement. Also, if one of the build fails, the script stops.

C++20 variadics with abbreviated function template

Today, when working with my stripped C++ Win32 library – after the frustration with Rust’s long compile times in WinSafe –, I was trying to implement an overloaded variadic method, in order to get rid of initializer_list. Then I stumbled upon a great article which introduced me to the abbreviated function template feature of C++20, which I’m using.

This is an example:

int foo(std::wstring n)
{
	OutputDebugStringW(n.data());
	OutputDebugStringW(L"\n");
	return 43;
}

int foo(std::wstring n, std::convertible_to<std::wstring> auto... nn)
{
	foo(n);
	return foo(nn...);
}

The convertible_to concept is particularly interesting in narrowing the template type.

Sizes of Windows integral types

While developing WinSafe, it’s very common to convert the Windows integral data types to their Rust equivalent. Care must be taken, however, when it comes to pointer size, which varies according to the architecture. Since WinSafe is aimed to both 32 and 64-bit Windows, I must pay attention.

For reference, below is the table I’m using to figure out the sizes:

Signed C	Signed Rust	Unsigned C	Unsigned Rust	32-bit	64-bit
CHAR	i8	UCHAR BYTE BOOLEAN	u8	8 bit (1 byte)
SHORT	i16	USHORT WCHAR WORD	u16	16 bit (2 byte)
BOOL INT LONG	i32	UINT ULONG DWORD	u32	32 bit (4 byte)
INT_PTR LONG_PTR LPARAM	isize	UINT_PTR ULONG_PTR WPARAM SIZE_T	usize	32 bit (4 byte)	64 bit (8 byte)
LARGE_INTEGER LONG64 LONGLONG	i64	ULARGE_INTEGER ULONG64 ULONGLONG DWORD64 DWORDLONG QWORD	u64	64 bit (8 byte)

The table above is an extension of this one.

My Visual C++ 2019 settings

Just for the record, these are the settings I’m always using with Visual Studio 2019, when creating a new, empty C++ project:

• General
  • Output Directory: $(SolutionDir)$(Platform)_$(Configuration)\
  • Intermediate Directory: $(Platform)_$(Configuration)\
  • C++ Language Standard: ISO C++20 Standard (/std:c++20)
• C/C++
  • General
    • Debug Information Format: None (Release)
    • Warning Level: Level4 (/W4)
    • Treat Warning As Errors: Yes (/WX) (Release)
    • SDL checks: Yes (/sdl)
    • Multi-processor Compilation: Yes (/MP)
  • Code Generation
    • Runtime Library: Multi-threaded (/MT) (Release)
  • Language
    • Conformance mode: Yes (/permissive-)
  • Advanced
    • Treat Specific Warnings as Errors: 4172;4715
• Linker
  • General
    • Enable Incremental Linking: No (/INCREMENTAL:NO) (Release)
  • Debugging
    • Generate Debug Info: No (Release)
  • System
    • SubSystem: Windows (/SUBSYSTEM:WINDOWS)
• Code Analysis
  • General
    • Enable Code Analysis on Build: Yes

As of April 2024, the settings above also apply to Visual Studio 2022.

As of June 2026, the settings above also apply to Visual Studio 2026.

The ghastly button focus

During my 20 years or so writing Win32 programs, I always relied on SetFocus to focus a control. However, I always noticed a weird behavior on push buttons regarding the BS_DEFPUSHBUTTON style, which was never right. In fact, I remember one of the past WinLamb incarnations which I implemented some trick involving changing the button style when setting the focus.

Anyway, now I found out how to properly set the focus on a control, and it does not involve SetFocus, but rather the WM_NEXTDLGCTL message:

SendMessage(hParent, WM_NEXTDLGCTL, (WPARAM)hButton, MAKELPARAM(TRUE, 0));

And the push button magically sets its own style correctly.

Validating lambda signatures in C++17

WinLamb, as the name itself implies, is heavily based on lambda functions. While searching a way to enforce the lambda signatures in the upcoming C++17 release, I received an incredible answer on StackOverflow:

#include <functional>
#include <type_traits>
	
template<typename F>
auto foo(F&& func) noexcept ->
	std::enable_if_t<
		std::is_same_v<
			decltype(std::function{std::forward<F>(func)}),
			std::function<void(int)>
		>, void
	>
{
	func(33);
}

Up to this point, I was completely unaware of the existence of trailing return types in function declarations.

The validation is extremely restrict, serving my purposes perfectly. And it seems that the upcoming C++20 concepts feature can simplify it quite a lot.

SFINAE and enable_if

Today, while researching for the upcoming C++17 version of WinLamb, I was rethinking the idea of restricting the allowed types on a template argument. That’s an SFINAE thing, scary to many people – including me sometimes, in my love-hate relationship with advanced C++ stuff.

The thing is that I ended up writing a working piece of code using std::enable_if to restrict a template argument, and I’m quite proud of it.

#include <type_traits>

struct One { int num; };
struct Two { int num; };
struct Tre { int num; };

template<
  typename T,
  typename = std::enable_if_t<
    std::is_same_v<T, One> ||
    std::is_same_v<T, Two>
  >
>
void foo(T& o) { ++o.num; }

int main() {
  One o;
  foo(o);
  return 0;
}

In the code above, One and Two classes will work with foo(), whereas Tre will not compile, despite being exactly like the others.

False memory leak reports of static objects

I was having a weird memory leak report in a C++ program, happening right after I close it, and triggered by a call to _CrtDumpMemoryLeaks, which exists in the very end of WinMain function in WinLamb. I was puzzled, because I’ve commented everything out, and I still had the memory leak.

Turns out _CrtDumpMemoryLeaks is called at the end of WinMain, before the static object destructors are called. And there you go: if any statically allocated object had made a heap allocation, the memory won’t be freed yet, thus the report.

I’m not the only one with this problem, but so far no solution had any effect. By now I’ll just avoid static allocation of objects which alloc memory on the heap, and carry on with life. Maybe I’m too used to the JavaScript blessings.

A very simple, raw Win32 WinLamb program

Months ago I noticed that WinLamb was missing a simple, introductory example. I never really had time to write and publish one. Until today.

Click lines is a very simple program, inspired by Charles Petzold, which draws lines upon mouse clicks. Just this. It’s intended to be a very simple showcase of WinLamb, showing how to create raw windows, raw custom controls, and handling messages. I usually use dialog boxes on my real-world programs, but for this one I really kept it bare-bones, with no dialogs.

I hope it can be useful to anyone interested in WinLamb.

SRTEd 1.3.1, minor release

This week I released a new SRTEd version 1.3.1, with has minor, but many usability improvements. Also, it’s built with latest version of WinLamb, my very own personal raw Win32 library, which I use for everything.

I was planning a bigger release for SRTEd, with more advanced features, but since my time is pretty short these days, I just released a version where it is now, with the UI improvements. It’s already more than a year since the last version, time flies. One notable difference is the absence of a 32-bit executable, which was not included because it was firing false positives for malware, something completely absurd. To avoid the hassle, I opted to keep only the 64-bit version.

SRTEd can be downloaded from CNET.

Alternative approach to bitflags in C++

Just wondering about a short, expressive and alternative way to implement bitflags in C++11.

Right now I don’t plan to adopt this idiom, but it doesn’t look so bad.

A C++ container which keeps insertion order

C++ is a poorly designed programming language, and I live a love-hate relatioship with it.

On my vacation days, when working on WinLamb for the next version of SRTEd, I needed a container to keep track of the order the elements were inserted. Among the many useless obscure things that C++ has, it doesn’t have such a container. So I had to write one, which after much struggle I named it the insert_order_map.

Usage example, including iterator support for C++11 range-based for loop:

insert_order_map<wstring, wstring> all = {
  { L"initial", L"blab" },
  { L"initial2", L"bleb" }
};

all[L"first"] = L"abcdef";
all[L"second"] = L"123456";

for (insert_order_map<wstring, wstring>::entry& e : all) {
  wstring key = e.key;
  wstring val = e.value;
}

At first I wondered about using a sentinel linear search, line the one used within store. But then I realized that 99% of the time I’ll be using a string as the key with few elements inserted, thus the initial copy of the string at each search would take away the performance gains of the sentinel algorithm. So I decided to stick to an ordinary linear search.

After 4 years, SRTEd 1.3.0

So finally I released a new version of SRTEd, my own subtitles editor. Honestly, in these four years I didn’t see a better subtitle editor, I still think it’s the most user-friendly editor out there.

The interface didn’t improve much, but there are many bugfixes and minor UI adjusts. It took so long because I entirely rewrote it using my new Win32 library, which I expect to release as open source soon, together with an article explaining what it is and how to take the best out of it.

It can be downloaded from CNET or Softpedia.

Git .gitignore file to Visual C++ 2015 Update 2

After upgrading my Visual C++ 2015 from Update 1 to Update 2, I noticed that a new file appeared in the root directory of the projects I was opening. The file was always named ProjectName.VC.db. Indeed according to the release notes, a new SQLite-based database engine is now being used by default, and that’s the file where the database is stored. The old file, named ProjectName.sdf is now unused and can be safely deleted.

The change also demanded an update on my .gitignore files to also ignore this new database file, and here it goes:

Debug/
Release/
*.aps
*.db
*.ffs_db
*.ncb
*.opensdf
*.rar
*.sdf
*.suo
*.user
*.VC.opendb
TODO.txt

If you import and old .vssettings file, however, the option to use the new SQLite-based database can be rolled back to the old .sdf files. To manually change it, go to: Tools → Options → Text Editor → C/C++ → Advanced → Browsing/Navigation → Enable New Database Engine. Set it to “true”.