/* This C implementation of singly linked list implements 3 operations: add, remove and insert elements at some specific position in
 * the list.
 *
 * VERISON 0.0
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct my_struct* add_to_list( struct my_struct *const, const int);
struct my_struct* remove_from_list( struct my_struct *const, const int );
struct my_struct* insert_after_element(struct my_struct *const, const int, const int);

void print_list( const struct my_struct* );

struct my_struct
{
  int num;
  struct my_struct* next;

  if( NULL == root_node )
    {
      fprintf(stderr, "IN %s, %s: malloc() failed\n", __FILE__, "main");
      return EXIT_FAILURE;
    }
  else
    {
      root_node->next = 0;
      root_node->next = NULL;
    }

  add_to_list(root_node, i);
  add_to_list(root_node, j);

  print_list(root_node);

  printf("going to remove element with value = %d\n", i);
  remove_from_list(root_node, i);
  print_list(root_node);

  printf("going to insert element after root_node\n");
  insert_after_element(root_node, root_node->num, i);
  print_list(root_node);

  return 0;

  if( NULL == p )
    {
      fprintf(stderr, "IN %s, %s: malloc() failed\n", __FILE__, "add_to_list");
      return NULL;
    }

  p->num = i;
  p->next = NULL;

  for( ; s != NULL ; s = s->next )  c = s;

  c->next = p;

  return c->next;

  for( ; (NULL != s) && (s->num != r); s = s->next ) c = s;

  if( s )
    {
      c->next = s->next;
      free(s);
      return c;
    }

  return NULL;

  for( ; (NULL != s) && (s->num != after ); s = s->next );

  if( NULL == s )
    {
      printf("No element with number match: %d\n", i);
    }
  else
    {
      p = malloc( 1 * sizeof(*p));

      if( NULL == p )
        {
          fprintf(stderr, "IN: %s, %s: malloc() failed\n", __FILE__, "insert_after_element");
          return NULL;
        }

      p->num = i;

      n = s->next;
      s->next = p;
      p->next = n;
    }

  return p;

  printf("\n\n");

going to remove element with value = 1
Num = 0
Num = 2

going to insert element after root_node
Num = 0
Num = 1
Num = 2

[arnuld@dune programs]$

An integer indicating success or failure may be more useful than the
structure.

My design for this sort of thing would have a function something
like :-

   void *list_create();

to initialise a list. The returned value (remaining as a void *) would
be my first argument to the other list management functions, which
could assign it to a my_struct * internally.

 void *create_list(); /* allocate and initialise root node */
 int add_to_list( void *list, const int value );
 int remove_from_list( void *list, const int value );
 int insert_after_element( void *list, const int value, const int
value2 );
 void print_list( void *list );
 void delete_list( void *list ); /* free all nodes (including the root
node) */

Also consider how you could generalise this easily - for example, what
you could do if the nodes had the form :-

struct my_struct {
  void *the_data;
  struct my_struct *next;

The add operation is then always:

  list = add_to_list(list, ...);

and similarly with remove.  This really simplifies the code.

If you are using what I consider a rather ugly trick of always having a
dummy first node, then I strongly advice you change that.  I don't
think you are doing that because the print function prints it!

I'd make all the function names start with a common prefix
(i.e. list_add, list_remove and so on).  It is a shame that this does
not produce natural meaning in English (the "list add" operation adds
a list not an item to a list in plain English) but all programmers
will know what you mean.

struct my_struct* list_add(struct my_struct *const base_node, const int i )
{
  struct my_struct* s = base_node;
  struct my_struct* c = NULL;
  struct my_struct* p = malloc( 1 * sizeof(*p));

  if( NULL == p )
    {
      fprintf(stderr, "IN %s, %s: malloc() failed\n", __FILE__, "list_add");
      return NULL;
    }

  p->num = i;
  p->next = NULL;

  for( ; s != NULL ; s = s->next );
  s = p;

  return s;

And even if it was tweaked to work, it looks like you're proposing
an O(n) algorithm for something that should be O(1). Which is
horrific.

WANTED:   To add an element to the singly linked list.
HAPPENS:  Nothing is added to the list.

/* This C implementation of singly linked list implements 3 operations: add, remove and insert elements at some specific position in
 * the list.
 *
 * VERISON 0.1
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct my_struct* list_add( struct my_struct *const, const int);

void list_print( const struct my_struct* );
void list_print_element(const struct my_struct *const );

struct my_struct
{
  int num;
  struct my_struct* next;

  list_add(root_node, 1);
  list_print(root_node);

  return 0;

  if( NULL == p )
    {
      fprintf(stderr, "IN %s, %s: malloc() failed\n", __FILE__, "list_add");
      return NULL;
    }

  p->num = i;
  p->next = NULL;

  if( NULL == s )
    {
      printf("Base Node was NULL, so adding current maloc()ed struct to base\n");
      s = p;
    }
  else
    {
      printf("Base node is non-NULL, so adding it to the end of the list\n");
      for( ; s != NULL ; s = s->next ) c = s;
      c = p;
    }

  return base_node;

  for( ; NULL != p; p = p->next )
    {
      list_print_element(p);
    }

  printf("\n------------------\n");

But I've also changed a few things that I found annoying or made it
unreadable, notably getting rid of the consts (I've never got my mind around
those), and using a typedef 'tnode' instead of those untidy structs
everywhere.

You can also make it a bit simpler if you are happy with the items being
added in reverse order. (And if you need them in order, there are better
ways than searching to the end of the list each time; imagine you have tens
of millions of nodes.)

Note: watch for line-wraps on the string constants, you may need to join
these up again.

/* This C implementation of singly linked list implements 3 operations: add,
remove and insert elements at some specific position in
 * the list.
 *
 * VERSION 0.1a
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct my_struct
{
  int num;
  struct my_struct* next;

tnode* list_add( tnode *, int);

void list_print(tnode* );
void list_print_element(tnode *);

int main(void)
{
  tnode* root_node = NULL;

  root_node = list_add(root_node, 1);  /* !!!!! */
  list_add(root_node, 16);
  list_add(root_node, 176);
  list_add(root_node, 1766);
  list_print(root_node);

  return 0;

  if(p==NULL) return base_node; /* Do not return NULL here */

  p->num = i;
  p->next = NULL;

  if(base_node==NULL)
    {
      printf("Base Node was NULL, so adding current malloc()ed struct to
base\n");
      base_node = p;
    }
  else
    {
      printf("Base node is non-NULL, so adding it to the end of the
list\n");
      s = base_node;
      while (s->next) s=s->next;
      s->next = p;
    }

  return base_node;

  puts("Printout of linked list:");
  for(p=sp ; p!=NULL; p = p->next )
    {
      list_print_element(p);
    }

  printf("\n------------------\n");

You must decide between one of three different designs:

(a) The list_add operation must always be used in an assignment.  It
return the new list: root = list_add(root, ...);

(b) You must pass a pointer to the list pointer so that list_add can
change it: list_add(&root, ...);

(c) You pass a pointer to some overall list structure (not the same as
the node structure) and list_add manipulates that.

The idea of having an unused head element is a version of this design
but I don't like it.  If the list is to be more sophisticated (say be
having a head and tail pointer, or extra information list the length)
then (c) is the way to go, but it is a more complicated design.

You really should not get any further until you are certain that you
can see why what you are doing can't work, and why all of the above are
ways to solve this fundamental problem.

For a simple list I suggest (a) but you will get sound advice from
sane and experienced people who will advocate (b) and/or (c).  When
you choose, stick with it until you are done -- changing part way
though makes giving advice almost impossible!

  struct node *root == NULL;
  ...
  root = list_add(root, 42);

is perfectly valid if list_add allocates a node and return a pointer
to the list.  It is particularly easy if the item is added at the
front of the list and there is no reason not to do that as far as I
can see.

If you have to add items to the end of the list you should use another
strategy (see item (c) in my other post) unless you are prepared to
pay the cost of traversing the list just to add an item.

Using the return value you'd write code like this:

  struct list_node {
       struct list_node *next;
       int number;
  };

  struct list_node *make_node(struct list_node *tail, int i)
  {
       struct list_node *np = malloc(sizeof *np);
       if (np) {
            np->next = tail;
            np->number = i;
       }
       return np;
  }

  struct list_node *list_add_head(struct list_node *list, int i)
  {
       return make_node(list, i);
  }

  struct list_node *list_add_tail(struct list_node *list, int i)
  {
       if (list) {
            list->next = list_add_tail(list->next, i);
            return list;
       }
       else return make_node(list, i);
  }

(Not tested.)  I've written both the front adding and the tail adding
version.  You can make the tail version iterative if you don't like
recursion, but you really need a different design or a list you can
efficiently add to the end of.

/* This C implementation of singly linked list implements 3 operations: add, remove and insert elements at some specific position in
 * the list.
 *
 * VERISON 0.2
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct my_struct* list_add( struct my_struct **, const int);

void list_print( const struct my_struct* );
void list_print_element(const struct my_struct *const );

struct my_struct
{
  int num;
  struct my_struct* next;

  list_add(&root_node, 1);
  list_print(root_node);

  return 0;

  if( NULL == p )
    {
      fprintf(stderr, "IN %s, %s: malloc() failed\n", __FILE__, "list_add");
      return NULL;
    }

  p->num = i;
  p->next = NULL;

  if( NULL == s )
    {
      printf("Base Node was NULL, so adding current maloc()ed struct to base\n");
      s = p;
    }
  else
    {
      printf("Base node is non-NULL, so adding it to the end of the list\n");
      for( ; s->next != NULL ; s = s->next);
      s->next = p;
    }

  return *base_node;

  for( ; NULL != p; p = p->next )
    {
      list_print_element(p);
    }

  printf("\n------------------\n");

  printf("Root node before: %x",root_node);
  list_add(&root_node, 1);
  printf("Root node after: %x",root_node);

root_node is 0 before, and still 0 after, so is not being changed.

list_add is now returning a value that is not being used, and it's not
changing root_node (for example by using *base_node=something).

I.e. after a call like list_add(&root, 42); root will be exactly the
same as it was before.

I could just re-write this to work, but surely it would help you more
if you work though what it does to see why it is not correct?

#include <stdio.h>
#include <stdlib.h>

void change_p1(int** p1, int* p2 );

int main(void)
{
  int i = 1;
  int j = 2;

  int* p1 = &i;
  int* p2 = &j;

  printf("*p1 = %d\n", *p1);

  change_p1(&p1, p2);

  printf("*p1 = %d\n", *p1);

  return 0;

So, the problem was I was using a local pointer to change the value of the
passed argument. I don't see why it is wrong to do so though. Here is the
new working code:

/* This C implementation of singly linked list implements 3 operations: add, remove and insert elements at some specific position in
 * the list.
 *
 * VERISON 0.3
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct my_struct* list_add( struct my_struct **, const int);

void list_print( const struct my_struct* );
void list_print_element(const struct my_struct *const );

struct my_struct
{
  int num;
  struct my_struct* next;

  printf("List default\n");
  list_print(list_head);
  printf("List after adding values\n");
  list_add(&list_head, 1);
  list_add(&list_head, 2);
  list_print(list_head);

  return 0;

  if( NULL == p )
    {
      fprintf(stderr, "IN %s, %s: malloc() failed\n", __FILE__, "list_add");
      return NULL;
    }

  p->num = i;
  p->next = NULL;

  if( NULL == *head )
    {
      /* printf("Base Node was NULL, so adding current maloc()ed struct to base\n"); */
      *head = p;
    }
  else
    {
      /* printf("Base node is non-NULL, so adding it to the end of the list\n"); */
      for( ; (*head)->next != NULL ; *head = (*head)->next);
      (*head)->next = p;
    }

  return *head;

  for( ; NULL != p; p = p->next )
    {
      list_print_element(p);
    }

  printf("\n------------------\n");

------------------
List after adding values
Num = 1
Num = 2

------------------
[arnuld@dune programs]$

Let's mess up your toy program in the same way.  First, your working
version:

    void change_p1(int** p1, int* p2 ) // working
    {
       *p1 = p2;
    }

(Play-by-play: p1 points to X, we dereference p1 to get X, and we assign
p2 into X, thus modifying it.  Pretty straightforward.)

Now I'll break it to make it more comparable to the non-working list_add:

    void change_p1(int** p1, int* p2 ) // BROKEN
    {
       int *foo = *p1;
       foo = p2;
    }

See that I never assigned anything to *p1, so nothing was changed from
the caller's perspective.  Only the local value of "foo" changed, which
means nothing to the caller.  (Play-by-play: p1 points to X, we use *p1
to get X, we make a copy of X in foo, and then we MODIFY THE COPY OF X
stored in foo.  The original X pointed to by p1 is never modified, and
this is why it doesn't work.)

Now just for fun, let's make it work again, still using an intermediate
local variable:

    void change_p1(int** p1, int* p2 ) // working again
    {
       int **frotz = p1;
       *frotz = p2;
    }

There's nothing stopping us from copying a pointer, so there I've copied
p1 into local variable frotz.  p1 and frotz both point to the same thing
now (they're both pointing to the same int*).  So I can dereference
either of them and modify what they both point to.  (Play-by-play: p1
points to X, we copy p1 into frotz so frotz also points at X, we
dereference frotz to get X , and we assign p2 into it, thus modifying
X.)  There are no copies of X in this example; there is only a copy of a
pointer to X.

To repeat myself, since frotz and p1 both point at the same thing, we
could dereference either of them to change what they both point at.
That is, I could have written "*p1 = p2" instead of "*frotz = p2" for
the exact same result, but then I would be right back at your working
example that I started with!

The important part is that we dereference p1 (or a copy of p1) and
assign into it.  (If we don't we assign into whatever p1 points at,
we'll never modify it, of course!*)  This is missing from the version
labeled "BROKEN", above.

-Beej, needs to sleep

/* This C implementation of singly linked list implements 3
operations: add, remove and insert elements at some specific position
in
 * the list.
 *
 * VERISON 0.4
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* How about always keeping track of tail of list (end of list I mean)
and then pass that to list_add(), that way, list_add() will always
   be O(1), rather than O(n)
*/
struct my_struct* list_add( struct my_struct **, const int);

void list_print( const struct my_struct* );
void list_print_element(const struct my_struct *const );

struct my_struct
{
  int num;
  struct my_struct* next;

  printf("List default\n");
  list_print(list_head);

  list_add(&list_head, 1);
  list_add(&list_head, 2);
  list_add(&list_head, 3);

  list_print(list_head);

  return 0;

  if( NULL == p )
    {
      fprintf(stderr, "IN %s, %s: malloc() failed\n", __FILE__,
"list_add");
      return NULL;
    }

  p->num = i;
  p->next = NULL;

  if( NULL == *head )
    {
      printf("Base Node was NULL, so adding current maloc()ed struct
to base: %d\n\n", p->num);
      *head = p;
    }
  else
    {
      printf("Base node is non-NULL, so adding it to the end of the
list: %d\n", p->num);
      for( ; NULL != (*head)->next; *head = (*head)->next ) ;
      (*head)->next = p;
    }

  return ps;

  for( ; NULL != p; p = p->next )
    {
      list_print_element(p);
    }

  printf("\n------------------\n");

------------------
Base Node was NULL, so adding current maloc()ed struct to base: 1

Base node is non-NULL, so adding it to the end of the list: 2
Base node is non-NULL, so adding it to the end of the list: 3
Num = 2
Num = 3

  struct my_struct *tail;
  for (tail = *head; NULL != tail->next; tail = tail->next);
  tail->next = p;