ATL / WTL / STL

// To write a memory efficient linked list
#include <iostream>
using namespace std;

// Node structure of a memory efficient doubly linked list
class Node {
public:
    int data;
    Node *npx;      //  XOR of next and previous node
};

// return XORed value of the node address
Node *XOR(Node *a, Node *b){
    return ((Node *)( (uintptr_t)(a) ^ (uintptr_t)(b) ));
}

// insert a node at the beggining of the XORed linked list and makes the newly inserted node as head
void insert(Node **head_ref, int data){
    // allocate memory for new node
    Node *new_node = new Node();
    new_node->data = data;

    // since node is inserted at the beggining, npx of the new node will always be XOR of curent head and null
    new_node->npx = XOR((*head_ref), nullptr);

    // if the linked list is not empty, then npx of current head node will be XOR of new node and node next to current head
    if(*head_ref != nullptr){
        // (*head_ref)->npx is XOR of null and next.
        // so if we do XOR of it with null, we get next
        Node *next = XOR((*head_ref)->npx, nullptr);
        (*head_ref)->npx = XOR(new_node, next);
    }

    // change head
    *head_ref = new_node;
}

// prints contents of doubly linked list in forward direction
void printList(Node *head){
    Node *curr = head, *prev = nullptr, *next;

    cout << "Following are the nodes of Linked List: \n";

    while(curr != nullptr) {
        // print current node
        cout << curr->data << " ";

        // get the address of next node : curr->npa is next^prev,
        // so curr->npx^prev will be next^prev^prev which is next
        next = XOR(prev, curr->npx);

        // update prev and curr for next iteration
        prev = curr;
        curr = next;
    }
}

// Driver function
int main(){
    Node *head = nullptr;
    insert(&head, 10);
    insert(&head, 20);
    insert(&head, 30);
    insert(&head, 40);
    insert(&head, 50);
    insert(&head, 60);

    printList(head);

    return 0;
}

Node *insert(Node **last, int data){
    // allocate memory for new node
    Node *new_node = new Node();
    new_node->data = data;

	new_node->npx = XOR(*last, nullptr);

	if(*last != nullptr) {
		Node *prev = XOR((*last)->npx, nullptr);
		(*last)->npx = XOR(prev, new_node);
	}

	// *last = new_node;
	return (new_node);
}

// Driver function
int main(){
    Node *head = nullptr;
    head = insert(&head, 10);
    head = insert(&head, 20);
    head = insert(&head, 30);
    head = insert(&head, 40);
    head = insert(&head, 50);
    head = insert(&head, 60);

    printList(head);

    return 0;
}

template <typename ParamType>
void Template_universal_ref(ParamType&& param)
{
    cout << "Template_universal_ref, param : " << param << endl;
}

void NonTemplate_universal_ref(int&& param)
{
    cout << "NonTemplate_universal_ref, param : " << param << endl;
}

int main()
{
    int x=5;
    Template_universal_ref(x);
    //NonTemplate_universal_ref(x); // This is giving compilation error
    return 0
}

NonTemplate_universal_ref(x);

Template_universal_ref(x);

void (*task_t)(uint8_t* taskData, uint16_t sizeOfTaskDataInBytes);

typedef enum {
    TASK_IN_WAIT_PHASE      = 0,
    TASK_FINISHED           = 1
} taskStatus_e;

typedef taskStatus_e (*getTaskStatusCallback_t)(uint8_t* data, uint16_t dataSizeBytes);

Bool_t queueTask(taskQueueSelector_e, task_t, uint8_t* data, uint16_t dataSizeBytes, getTaskStatusCallback_t);
Bool_t queue2Tasks(taskQueueSelector_e, task_t task1, uint8_t* data1, uint16_t data1SizeBytes, getTaskStatusCallback_t getTaskStatusCallback1, task_t task2, uint8_t* data2, uint16_t data2SizeBytes, getTaskStatusCallback_t getTaskStatusCallback2);

struct SPI_secretData_s {
    volatile Bool_t                    accessInProgress;
    volatile int8_t                    numRetriesLeft;
};

#define PLEASE_SEE_NUM_REGS_TO_ACCESS_PARAMETER     (1)

struct SPI_readRegsTaskParams_s {
    struct SPI_secretData_s            secretData;
    volatile uint32_t                  startAddr;
    volatile uint16_t                  numRegsToAccess;
    volatile SPI_readStatus_e          readStatus;
    volatile uint16_t                  readBuffer[PLEASE_SEE_NUM_REGS_TO_ACCESS_PARAMETER];
};

queue2Tasks(SPI_QUEUE_SELECTOR, SPI_readRegs, (uint8_t*)&SPI_readRegsTaskParams, sizeof(SPI_readRegsTaskParams), SPI_getTaskStatusCallback, SPI_handleReadIsFinished, NULL, 0, NULL);

taskStatus_e SPI_getTaskStatusCallback(uint8_t* data, uint16_t dataSizeBytes) {
    struct SPI_readRegsTaskParams_s* SPI_readRegsTaskParams = (struct SPI_readRegsTaskParams_s*)data;
    return (SPI_readRegsTaskParams->secretData.accessInProgress) ? TASK_IN_WAIT_PHASE : TASK_FINISHED;
}

uint32_t SPI_handleReadIsFinished(uint8_t* notUsed, uint16_t sizeOfNotUsedInBytes) {
    struct SPI_readRegsTaskParams_s* SPI_readRegsTaskParams = (struct SPI_readRegsTaskParams_s*)getPreviousTaskData();
    //... Do what you need to do with the read data...
}

struct CAN_secretData_s {
    volatile Bool_t                         accessInProgress;
};

struct CAN_readRegsTaskParams_s {
             struct CAN_secretData_s        secretData;
    volatile uint32_t                       startAddr;
    volatile uint8_t                        numRegsToReadMax4;
    volatile uint16_t                       readRegsBuffer[4];
    volatile CAN_readStatus_e               readStatus;
};

queue2Tasks(CAN_QUEUE_SELECTOR, CAN_readRegs, (uint8_t*)&CAN_readRegsTaskParams, sizeof(CAN_readRegsTaskParams), CAN_getTaskStatusCallback, CAN_handleReadIsFinished, NULL, 0, NULL);

taskStatus_e CAN_getTaskStatusCallback(uint8_t* data, uint16_t dataSizeBytes) {
    struct CAN_readRegsTaskParams_s* CAN_readRegsTaskParams = (struct CAN_readRegsTaskParams_s*)data;
    return (CAN_readRegsTaskParams->secretData.accessInProgress) ? TASK_IN_WAIT_PHASE : TASK_FINISHED;

uint32_t CAN_handleReadIsFinished(uint8_t* notUsed, uint16_t sizeOfNotUsedInBytes) {
    struct CAN_readRegsTaskParams_s* CAN_readRegsTaskParams = (struct CAN_readRegsTaskParams_s*)getPreviousTaskData();
    //... Do what you need to do with the read data...
}

void (*task_t)(uint8_t* taskData, uint16_t sizeOfTaskDataInBytes);

Bool_t addTaskToQueue(queueSelector_e, task_t, uint8_t* taskData, uint16_t sizeOfTaskDataInBytes);

struct writeRegTaskData_s {
    uint32_t startAddr;
    uint16_t numRegsToWrite;
    uint8_t dataToWrite[numRegsToWrite]; // When I want the data to be put inside the queue as well
or
    uint8_t* dataToWrite // When I have a big static buffer that I don't want to put inside the queue
}

typedef union _UINT32_PART_ {
   uint32_t dwWord;

   struct {
      uint16_t dwMSB;
      uint16_t dwLSB;
   } hw;

   struct {
      uint8_t byMSB;
      uint8_t byMSBL;
      uint8_t byLSBH;
      uint8_t byLSB;
   } b;
} DWORD_PART;

typedef union _UINT32_PART_ {
   uint32_t dwWord;

   struct {
                         // 2 bytes empty gap
      uint16_t dwLSB;    // This must still point to the 2nd word, not the 1st!
   } hw;

   struct {
      uint8_t byMSB;
      uint8_t byMSBL;
                         // 1 byte empty gap
      uint8_t byLSB;     // This must still point to the 4th byte, not the 3rd!
   } b;
} DWORD_PART;