You are looking for Enumerable.Empty<T>().

In other news the Java empty list sucks because the List interface exposes methods for adding elements to the list which throw exceptions.

int Player::addToInv(Thing& t) {
if (inventory.size() <= 52) {
    inventory.push_back(&t);
} else {
    shiplog("Cannot add to inventory, 52 item limit reached",10);
    return 0;
}

}

Thing is passed by reference, but then its address is passed to inventory.push_back(). Try just passing 't'.

This is a basic program for implementing stack data structure and its operations. Hope it will help you.

#include<stdio.h>
#include<stdlib.h>
#define INT_MIN -99;

struct Stack{
    int data;
    struct Stack *next;
};

struct Stack *CreateStack(){
    return NULL;
}

void Push(struct Stack **top,int data){
    struct Stack *temp;
    temp=malloc(sizeof(struct Stack));

    if(!temp)
        return NULL;

    temp->data = data;
    temp->next= *top;

    *top=temp;
}

int IsEmptyStack(struct Stack *top){
    return top==NULL;
}

int Pop(struct Stack **top){
    int data;
    struct Stack *temp;

    if(IsEmptyStack(*top))
        return INT_MIN;

    temp=*top;
    *top=temp->next;
    data=temp->data;
    printf("%d",data);
    free(temp);
    return data;
}

int Top(struct Stack *top){
    if(IsEmptyStack(top))
        return INT_MIN;

    return top->next->data;
}

void DeleteStack(struct Stack **top)
{
    struct Stack *temp,*p;
    p=*top;
    while(p->next){
        temp=p->next;
        p->next=temp->next;
        free(temp);
    }

    free(p);
}

void main(){

    struct Stack *s=CreateStack();
    Push(&s,5);
    Push(&s,15);
    Push(&s,52);
    Pop(&s);
    Pop(&s);
    Push(&s,35);
    Push(&s,53);
    Pop(&s);
    Push(&s,45);

}

It's really easy:

myList.Clear();

One can declare to ignore the unused variable:

(defun emptystack ()
  (dolist (var *stack*)
    (declare (ignore var))
    (pop *stack*)))

With the DO macro:

(defun emptystack ()
  (do ()                ; no bindings
      ((null *stack*))  ; end test, no further results
    (pop *stack*)))     ; body

In LOOP one can also ignore the variable by naming it nil:

(defun emptystack ()
  (loop for nil in *stack* do (pop *stack*)))

First of all you don't need double pointer. Initialization with NULL is important here. (Denotes the empty list).

SortedList *list = NULL;

This has the benefit that now if you want to make changes to it pass it's address.

func(&list);

And checking the empty list would be

   void func(SortedList **list){
      if( *list == NULL )
        /* empty */
   }

This is usually the way lists are implemented.

In your case you simply allocated to a local variable and instead of returning the memory address you have overwritten the pointer's value with NULL - there is memory leak in the code.

With your code it will be something like. Yes all that the initialization does is assigning it to NULL. This is one easy way out towards checking the NULL. At the very beginning making it NULL basically denotes that list is empty.(which is the case generally).

You can use Enumerable.Any:

bool isEmpty = !list.Any();
if(isEmpty)
{
    // ...
}  

If the list could be null you could use:

bool isNullOrEmpty = list?.Any() != true;