C / C++ / MFC

arm-linux-gnueabihf

/usr/arm-linux-gnueabihf/include/c++/5/exception:63:39: sorry, unimplemented: Thumb-1 hard-float VFP ABI
     exception() _GLIBCXX_USE_NOEXCEPT { }
                                       ^
src/subdir.mk:18: recipe for target 'src/Zero.o' failed

arm-linux-gnueabihf

--build=x86_64-linux-gnu --host=x86_64-linux-gnu –target=arm-linux-gnueabihf

x86_64-linux-gnu

x86_64-linux-gnu

arm-linux-gnueabihf

int  main ()
{
  ECU_t ecu;
  ecu.engine = (Engine_t *) malloc(sizeof(ecu.engine)); // allocate memory fot the Engine_t struct
  ECU_DoTask(&ecu);
  printf("water_temp = %d\n", ecu.engine->water_temp);
  free( ecu.engine); // release allocated dynamic memory

  return 0;
}

output->engine->water_temp = NORMAL;

typedef enum
{
	NORMAL = 0,
	WARNING = 1,
} WATER_TEMP;

typedef struct {
	WATER_TEMP water_temp;
	uint16_t speed;
	// ... other members
} Engine_t;

typedef struct
{
	Engine_t engine;  // <== Not a pointer anymore
	// ... other members
} ECU_t;

int main(void)
{
	/* This creates a test instance .. requires C99 or higher wont work on old C89 compiler */
	ECU_t ecu_test = { .engine.water_temp = NORMAL,
		           .engine.speed = 10 };

        /* You access them in the normal way */
	printf("Water temp is %i\n", ecu_test.engine.water_temp);
	printf("Engine speed is %i\n", (unsigned int)ecu_test.engine.speed);
}

void ECU_DoTask(ECU_t* out_ecu)
{
  // perform out_ecu->engine->speed = ...
  // perform out_ecu->abs->status = ...
  // perform out_ecu->bcm->high_beam_status = ...
}

/* This is called a static allocation */
/* You use the & symbol to make a pointer to the allocation */
static ECU_t ecu_test;
ECU_DoTask(&ecu_test);

/* This is called a dynamic allocation */
/* malloc makes space for the structure on the heap and gives you a pointer */
ECU_t* ecu_test = malloc(sizeof(ECU_t));
ECU_DoTask(ecu_test);

Member 13128005 wrote:

Any help??

CPallini wrote:

Using an array of K pointers

1. Given a singly-linked list of length k, reverse the order of the elements
2. Given a singly-linked list of length 2*k, reverse the order of the first k elements, without touching the last k elements. Return a pointer to the k^th element (counting from zero).
3. Given a singly-linked list of length 2*k, reverse the order of the last k elements.
4. Given a singly-linked list of length 3*k, reverse the order of the middle k elements. return a pointer to the 2*k^th element (counting from zero).
5. Put everything together to get the solution to your problem.

Member 14055543 wrote:

Can anyone point me in the right direction?