C中的按位运算符

Question

I'm doing a project which is relevant to beautification code.Actually this programm i'm supposed to write is in C and works in same way as pretty print or index(if you're heard about them).My question is:I 've searched through the internet and found a similar code to my project but it uses bitwise operators.In which way can i modify my programm so not to use this operators?This is a code that i found through the internet..I hope someone can help me and tell me how can i get rid of these operators and instead write a code without them.Thanks a lot!

#define FLAG_PRINT          ( 1 << 0 )
#define FLAG_NEWLINE        ( 1 << 1 )
#define FLAG_TABS           ( 1 << 2 )

void print_tabs(int count)
{
  int i;
  for(i = 0; i < count; i++)
    putchar('\t');
}

int main()
{
int ch;
int fflags = 0;
int lflags = 0;
int tab = 0;
while ( (ch = getchar()) != EOF )
{
    //////////////// flag setting
    switch(ch)
    {
    case ';':
        fflags |= FLAG_PRINT;
        lflags |= FLAG_NEWLINE | FLAG_TABS;
        break;
    case '{':
        fflags |= 0 ;
        lflags |= FLAG_NEWLINE | FLAG_TABS | FLAG_PRINT;
        tab++;

        break;
    case '}':
        fflags |= FLAG_NEWLINE | FLAG_TABS;
        lflags |= FLAG_NEWLINE | FLAG_TABS | FLAG_PRINT;
        tab--;
        break;
    case ' ':
        fflags |= FLAG_PRINT;
        break;
    default:
        if(!isspace(ch))
            fflags |= FLAG_PRINT;
    }
    ////////////////////////////////////////

    /// first order flags
    if(fflags & FLAG_PRINT)
        putchar(ch);
    if(fflags & FLAG_NEWLINE)
        putchar('\n');
    if(fflags & FLAG_TABS)
        print_tabs(tab);

    // last order flags
    if(lflags & FLAG_PRINT)
        putchar(ch);
    if(lflags & FLAG_NEWLINE)
        putchar('\n');
    if(lflags & FLAG_TABS)
        print_tabs(tab);

    //reset
    fflags = 0;
    lflags = 0;
  }

return 0;
}

Answer 1

If all values are distinct single bits (so you never get carry), you can use '+' to achieve the effect of '|'.

Shift can be replaced by multiplication/division by powers of two.

Some of the other operators are harder to replace while still doing bitwise operations. You may be able to precompute, or implement your own functions using table lookup, or you might want to use something like an array rather than bit flags within an int.

But the real-world answer is that bitwise operations exist for good reasons, and it's foolish not to use them when you need them.

Answer 2

Here are int values that are the same as the #defines at the top of the program. However, the #defines are usable with more data types than the const int values

#define FLAG_PRINT          ( 1 << 0 )
#define FLAG_NEWLINE        ( 1 << 1 )
#define FLAG_TABS           ( 1 << 2 )

can also be written as:

const int FLAG_PRINT   = 0x01;
const int FLAG_NEWLINE = 0x02;
const int FLAG_TABS    = 0x04;

suggest, for good programing practice,
changing the names to something like:
flagPrint
flagNewline
flagTabs

Answer 3

Although using bits seems like the best way to do it, if you insist on not using bits, you can do it with bitfields like this:

typedef union Flags {
    unsigned int allFlags;
    struct {
        unsigned int print   : 1;
        unsigned int newline : 1;
        unsigned int tabs    : 1;
    };
} Flags;

Flags fflags = {0};

// To set flags:
fflags.print   = 1;
fflags.newline = 1;

// To test a flag:
if (fflags.print) {
}

// To clear all flags:
fflags.allFlags = 0;

If you don't know anything about bitfields or unions, then do the completely simple way like this:

typedef struct Flags {
    int print;
    int newline;
    int tabs;
} Flags;

Flags fflags = {0};

// To set flags:
fflags.print   = 1;
fflags.newline = 1;

// To test a flag:
if (fflags.print) {
}

// To clear all flags:
memset(&fflags, 0, sizeof(fflags));

// Or if you never used memset:
fflags.print   = 0;
fflags.newline = 0;
fflags.tabs    = 0;