Is there a shorthand byte notation in C/C++?


It’s been awhile since I programmed in C/C++. For the life of me, I cannot remember (or find in Google) how to make the following work. I thought there was a shorthand way of writing a repeating string of bytes, like these:

0x00 => 0x00000000

For example, if I was to declare

int x = 0xCD;
printf("%d", x);

it would print 3452816845, not 205.

Am I going crazy?

Is it possible without doing runtime bit shifts (e.g., by making the preprocessor handle it)?

asked on Stack Overflow Nov 1, 2011 by Jay • edited Jan 26, 2021 by ib.

7 Answers


The simplest way is:

0x1010101u * x

I can't think of any syntax that could possibly be simpler or more self-explanatory...

Edit: I see you want it to work for arbitrary types. Since it only makes sense for unsigned types, I'm going to assume you're using an unsigned type. Then try

#define REPB(t, x) ((t)-1/255 * (x))
answered on Stack Overflow Nov 1, 2011 by R.. GitHub STOP HELPING ICE • edited Jan 26, 2021 by R.. GitHub STOP HELPING ICE

There's nothing like that by default in C. There's something similar in CSS (the color #123 is expanded to #112233), but that's completely different. :)

You could write a macro to do it for you, though, like:

#define REPEAT_BYTE(x) ((x) | ((x) << 8) | ((x) << 16) | ((x) << 24))
int x = REPEAT_BYTE(0xcd);

Unless you write your own macro, this is impossible. How would it know how long to repeat? 0xAB could mean 0xABABABABABABABABABABAB for all it knows (using the proposed idea).

answered on Stack Overflow Nov 1, 2011 by jli

There is no such shorthand. 0x00 is the same as 0. 0xFF is the same as 0x000000FF.

answered on Stack Overflow Nov 1, 2011 by David Schwartz

You could use some template trickery:

#include <iostream>
#include <climits>

using namespace std;

template<typename T, unsigned char Pattern, unsigned int N=sizeof(T)>
struct FillInt
    static const T Value=((T)Pattern)<<((N-1)*CHAR_BIT) | FillInt<T, Pattern, N-1>::Value;

template<typename T, unsigned char Pattern>
struct FillInt<T, Pattern, 0>
    static const T Value=0;

int main()
    cout<<hex<<FillInt<unsigned int, 0xdc>::Value<<endl; // outputs dcdcdcdc on 32 bit machines

which adapts automatically to the integral type passed as first argument and is completely resolved at compile-time, but this is just for fun, I don't think I'd use such a thing in real code.

answered on Stack Overflow Nov 1, 2011 by Matteo Italia

Nope. But you can use memset:

int x;
memset(&x, 0xCD, sizeof(x));

And you could make a macro of that:

#define INITVAR(var, value) memset(&(var), (int)(value), sizeof(var))
int x;
answered on Stack Overflow Nov 1, 2011 by Andrew Cottrell

You can use the preprocessor token concatenation:

#include <stdio.h>
#define multi4(a) (0x##a##a##a##a)

int main()
    int a = multi4(cd);
    printf("0x%x\n", a);
    return 0;



Of course, you have to create a new macro each time you want to create a "generator" with a different number of repetitions.

answered on Stack Overflow Nov 1, 2011 by Grimflo

User contributions licensed under CC BY-SA 3.0