C / C++ / MFC

#include <stdio.h>
int main (void){
   int *base = 0;
   int offset = 1;
   volatile int *result;
   result = base + offset;
   printf("Volatile result pointer = %p\n", result);
   if ((int)result != sizeof(int)) printf("compiler is broken\n");
}

#include <stdint.h>
#include <stdio.h>
int main (void){
   uint32_t *base = 0;
   uint32_t offset = 1;
   volatile uint32_t *result;
   result = base + offset;
   printf("Volatile result pointer = %p\n", result);
}

Quote:

There are no overload for pointers to non-static member, pointers to volatile, or function pointers (other than the ones with signatures accepted by the (10-12) overloads). Attempting to output such objects invokes implicit conversion to bool, and, for any non-null pointer value, the value 1 is printed

cout << (char*)0x41 << endl;    // This will crash and burn .. it expects a null terminated string from a char*
cout << (void*)0x41 << endl;    // This will print fine

cout << "result " << (void*)result << '\n';

Quote:

So - is the BCM2835 memory "only" 8 bits wide?

Vaclav_ wrote:

if I use uint32_t adding 1 results in pointer being incremented by 4. If I use uint8_t same process increments the pointer by 1.

Quote:

If uint32 is 4 bytes wide - why did they name it "32"?

/*--------------------------------------------------------------------------}
{  RASPBERRY PI SYSTEM TIMER HARDWARE REGISTERS - BCM2835 Manual Section 12	}
{--------------------------------------------------------------------------*/
struct __attribute__((__packed__, aligned(4))) SystemTimerRegisters {
	uint32_t ControlStatus;											// 0x00
	uint32_t TimerLo;												// 0x04
	uint32_t TimerHi;												// 0x08
	uint32_t Compare0;												// 0x0C
	uint32_t Compare1;												// 0x10
	uint32_t Compare2;												// 0x14
	uint32_t Compare3;												// 0x18
};

#define GPIO ((volatile __attribute__((aligned(4))) uint32_t*)(uintptr_t)(RPi_IO_Base_Addr + 0x200000))

leon de boer wrote:

4 bytes each of 8 bits = 4 x 8 = 32 bits .. its unsigned and a type .... so uint32_t
8 bytes of 8 bits = 8 x 8 = 64 bits .... so uint64_t also means 8 bytes.
Unlike int, long etc the sizes in bits and bytes are fixed in stone on every C compiler that meets the standard.

Quote:

Various implementations of C and C++ reserve 8, 9, 16, 32, or 36 bits for the storage of a byte

for (int j=0; j<COL; j++)
    cout << " " << (int)*(ptr+i+j) << endl;
cout << endl;

int *getArray()
{
	static int tab[ROW][COL] = {
		11, 12, 13, 14,
		21, 22, 23, 24,
		31, 32, 33, 34,
	};
	return (int*)tab;
}

int *ptr = getArray();
	cout << "\n Array tab[][] in main(): " << endl << endl;
	for (int i = 0; i<ROW; i++)
	{
		for (int j = 0; j<COL; j++)
			cout << " " << ptr[i*COL + j];
		cout << endl;
	}

int main()
{
  int (*ptr)[N];
  int (*getArray())[N];
  ...
}

int (*getArray())[N]
{
  ...
  return tab;
}

volatile uint32_t *TEST