Computers work in a mixture of bits, bytes and different kinds of words and lines too, depending on the component
e.g. on a 32-bit CPU, you can't really just operate on 1 bytes, you're usually operating on a whole word (and using masking to only seem to work on one byte), meanwhile your memory controller might work on 512bit lines of data, fetched from 8bit-aligned addresses...

Most CPUs have lots of nice instructions to work with bits, such as popcnt (count the 1's in a word), find index of first 1 from left/right end of word, count leading/trailing zeros, etc... You can use these to very efficiently iterate through arrays of bits.

access them by shifting

yeah I know but that shifting wastes some time
In c++ is there any way to read bit by bit without modifying a byte?

On a modern CPU you can't access a word byte-by-byte without shifting either
The amount of time that is "wasted" is probably so small that you won't notice if it's written well. Fetching your arrays of bytes from RAM to the CPU will likely be orders of magnitude slower than the CPU code for iterating through them.

Can you post some psuedo-code of what you want to do? Something like this?

rayLength = 0
for( int i=0; i!=end; ++i )
  if( bits[i] )
    rayLength = i;
    break;

I suggest reading about boolean operation, like "and", "or", "xor" and "not", being the most importants. Suppose you want to read the first bit of a 32 bits integer, you do something like this:

// True if the first bit is set to 1

if((x & 0x00000001) > 0)

What this operation does is set every bit of x to 0, but keep the first one unchanged (it dosent change x, but a copy of it). But what if you want the fifth one?

if(((x & (1 << 4)) > 0)

This work if you are testing a single bit at least.

I also made a class that can read a bit from a starting adresses, so it can read the 1000 bit of a very long array if you wish so, or it can work for a single BYTE as well

#include "Bits.h"

////////////////////////////////////////////////////////////////////////////////////////////////
// Return information about the bit position into the bitfield
////////////////////////////////////////////////////////////////////////////////////////////////
BYTE* Setup(void *pBitField, DWORD BitIndx, DWORD *pBitShift)
{
	BYTE *pData = (BYTE*)pBitField;
	pData += BitIndx / 8;
	*pBitShift = BitIndx % 8;
	return pData;
}

////////////////////////////////////////////////////////////////////////////////////////////////
// Return true if the bit is set to 1
////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadBit(void *pBitField, DWORD BitIndx, DWORD DataSize)
{
	// Make sure we aren't testing beyond the data memory limit
	if(DataSize > 0 && (BitIndx/8)+1 > DataSize)
		return false;

	// Tell how many bits to shift in the byte pointer below
	DWORD BitShift = 0;
	// Make a BYTE pointer to simplify things...
	BYTE *pData = Setup(pBitField, BitIndx, &BitShift);
	// Return true if the bit is set to 1
	return ((*pData >> BitShift) & 0x01) > 0;
}

////////////////////////////////////////////////////////////////////////////////////////////////
// Write 0 or 1 into the bitfield 
////////////////////////////////////////////////////////////////////////////////////////////////
void WriteBit(void *pBitField, DWORD BitIndx, BYTE BitValue, DWORD DataSize)
{
	// Make sure we aren't writing beyond the data memory limit
	if(DataSize > 0 && (BitIndx/8)+1 > DataSize)
		return;

	// Make sure the value here is only 0 or 1
	BitValue = (BitValue & 0x01);

	// Tell how many bits to shift in the byte pointer below
	DWORD BitShift = 0;
	// Make a BYTE pointer to simplify things...
	BYTE *pData = Setup(pBitField, BitIndx, &BitShift);

	// Set the bit to 0 or 1
	switch(BitValue)
	{
	case 1:	 *pData |=  (0x01 << BitShift); break;
	default: *pData &= ~(0x01 << BitShift); break;
	}
}

I also made this bit array class, which let you use the [ ] to set or get any bits you want in the array, might be a bit advanced for you but anyway, here it is

#include "BitArray.h"

CBitArray::CBitArray()
{
	pBuffer = NULL;
	BufferSize = 0;
	BitsCount  = 0;
}

CBitArray::~CBitArray()
{
	FreeMem();
}

bool CBitArray::IsAllocated()
{
	return pBuffer != NULL;
}

void CBitArray::Allocate(UINT NumBits)
{
	if(IsAllocated() || NumBits == 0){return;}

	BitsCount  = NumBits;
	BufferSize = ((NumBits-1)/8)+1;

	pBuffer = new BYTE[BufferSize];
	ClearAll();
}

void CBitArray::Resize(UINT NumBits)
{
	if(!IsAllocated() || NumBits == 0){return;}

	BYTE *pTmpBuffer = new BYTE[BufferSize];
	memcpy(pTmpBuffer, pBuffer, BufferSize);

	UINT NewBitsCount  = NumBits;
	UINT NewBufferSize = ((NumBits-1)/8)+1;

	delete [] pBuffer;
	pBuffer = NULL;
	pBuffer = new BYTE[NewBufferSize];
	
	ZeroMemory(pBuffer, NewBufferSize);
	if(NewBufferSize >= BufferSize){
		memcpy(pBuffer, pTmpBuffer, BufferSize);
	} else {
		memcpy(pBuffer, pTmpBuffer, NewBufferSize);
	}

	BitsCount  = NewBitsCount;
	BufferSize = NewBufferSize;

	delete [] pTmpBuffer;
}

void CBitArray::FreeMem()
{
	if(IsAllocated()){
		delete [] pBuffer;
		pBuffer = NULL;
		BufferSize = 0;
		BitsCount  = 0;
	}
}

bool CBitArray::operator[](UINT Indx)
{
	if(!IsAllocated() || Indx >= BitsCount){return false;}
	return ReadBit(pBuffer, Indx, BufferSize);
}

void CBitArray::ClearAll()
{
	if(!IsAllocated()){return;}
	ZeroMemory(pBuffer, BufferSize);
}

void CBitArray::SetAll()
{
	if(!IsAllocated()){return;}
	memset(pBuffer, 1, BufferSize);
}

bool CBitArray::GetBit(UINT Indx)
{
	if(!IsAllocated() || Indx >= BitsCount){return false;}
	return ReadBit(pBuffer, Indx, BufferSize);
}

void CBitArray::SetBit(UINT Indx, bool Value)
{
	if(!IsAllocated() || Indx >= BitsCount){return;}
	WriteBit(pBuffer, Indx, Value, BufferSize);
}

I don't use those classes anymore, since i now know how to work with the boolean operators, but still it could be usefull to learn from, or make complex operations much easier. (Never really used the bit array class, so it haven't changed since i wrote it, but i tested it a lot and it work)

You can even do it using assembly if you feel couragous.

I imagine that the dir*i/100 bit will get a bit messy when working in small quantized units like this.

I'd approach converting the ray into a voxelized version of itself, e.g. in 2D, you've got an idealized line that you want to trace:


You'd end up with a pixel version of the line, like this, which can be described as a series of 'spans' - a horizontal start/end point per row.


So, for example, the span on row 4 starts at 4 and ends at 6, or the span on row 3 starts at 7 and ends at 11.


For each span, you can iterate through the bytes that the span covers, and AND the span against the actual voxel data to check for collisions.
(This code is untested, and assumes the line is travelling from left to right. Right to left is a simple variation)

int checkSpan( int first, int last, unsigned char* rowOfBits )
{
  //for each byte covered by the span
  int byteBegin = first >> 3;
  int byteEnd   = (last+1) >> 3;
  for( int byte = byteBegin; byte != byteEnd; ++byte )
  {
    //find the range of the span within this byte
    int firstBit = max(0, first - 8*byte);
    int lastBit = min(7, last - 8*byte);
    int numBits = lastBit - firstBit + 1;

    //Create a mask that has 1's in this span, and 0's outside of it.
    //Use arithmetic shift to generate a mask numBits wide in the high end.
    //Use logical shift move the generated mask so it begins at firstBit.
    unsigned char mask = ((unsigned char) (((signed char)0x80) >> (numBits-1)) >> (8-numBits-firstBit));

    //check the mask against the row data to see if we overlapped a solid voxel
    unsigned char collision = mask & rowOfBits[byte];
    if( collision )
    {
      //find the index of the first bit in the overlapping area
      int firstBitHit = LeastSignificantBitSet( collision ); //bsf instruction
      //return the index of that bit within the row
      return firstBitHit + byte*8;
    }
  }
  return -1;
}

You wouldn't do this with bytes though -- you'd use the native word size of the CPU. For a 64-bit CPU, you could be checking 64-voxel wide spans per iteration of that loop.
Because the CPU works with words instead of bits, this basically means that your inner loop is now automatically parallelized 64x! Instead of having to work through bit by bit, you can work in bulk in huge arrays of bits at once.

If you went all out on a modern 2013 CPU, you could use 512bit AVX registers to be checking 512-voxel wide spans at once, and parallelize the algorithm over 4 cores to be checking 4 of these spans at once, for a total of up to 2048 voxels per iteration of that for loop above.

n.b. however, that algorithm only performs at peak performance for near-horizontal lines. For vertical lines you have lots and lots of very, very thin spans, which produce small masks, which means you don't get the full parallelization benefit of the large word size.
To combat this, you could store two copies of your voxel data set -- one as above, and the second one rotated 90º so that the bytes store 8 values in the y-direction instead of in the x-direction.
For a 3D data set, you'd store a 3rd copy of the data, laid out so that the bytes stores 8 values in the z-direction.

You'd then first check which axis the ray is strongest in, and use either the x, y, or z optimized version of the voxel data.