How to implement singleton object in C?

Question

I have a requirement for an OBJECT to be used by other objects. The requirement is that the OBJECT not require initialization by any external call. So I began with something like so...

//  .h
struct My_Shared_Obj {
  bool is_happy;
  struct foo *foos;
};

typedef struct My_Shared_Obj *mysharedobj;

//  .c
static mysharedobj MSO = NULL;

mysharedobj __instance();
void __mso_do_something();

void __mso_do_something() {
  mysharedobj _mso = __instance();

  // now do something with struct members
}

mysharedobj __instance() {
  if(MSO == NULL) {
    // initialize MSO
  }

  return MSO;
}


// we have an 'API' as follows
const struct MSO_API API = {
  .do_something = &__mso_do_something
};

Is this the best way to implement a self-initializing object?
Reference behavior doesn't seem to make changes to MSO but only for the scope of the function

Additionally, there are functions within this same source that are only accessible through the API ... ex:

static mysharedobj MSO = NULL;

/*
  This method makes an assumption that since it can ever only be called by an API function
  that the __instance() function has been invoked and that MSO will be a valid object.
*/
void __foo_add(foo *ptr) {
  // assume we have next incrementing somewhere
  MSO->foos[next] = *ptr;
}

void __mso_do_something() {
  struct My_Shared_Obj _mso = __instance();

  // hypothetical condition; assume we have a function that provides a foo for us...
  if (!_mso->is_happy) {
    __foo_add(get_a_foo());
    _mso->is_happy = true;
  }
}

I'm having difficulty getting the MSO object to be correctly referenced. The examples above are not contrived. It is what I have tried (names have been changed to protect the innocent). I have been experimenting with this for a bit now and not getting the results I need.

EDIT:
Corrected some typos. For what it's worth, the work I'm doing is not concerned with constraints of ISO standards. Thanks for the considerations, though.

Create an API, a set of functions, which is the only way to access and work with the singleton object. — Some programmer dude
– Some programmer dude, Commented Sep 7, 2024 at 15:31
@Someprogrammerdude ... I was thinking about that. I didn't want to create that extra late if it wasn't necessary. — IAbstract
– IAbstract, Commented Sep 7, 2024 at 15:47
What OS(es) and compiler(s) do you need to support? What version(s) of the C standard can be used? How portable and/or strictly-conforming to one of the versions of the C standard to you want/need your code to be? Does the code need to be thread-safe? Those will all strongly impact an implementation. Also - names that start with two underscores are reserved: "All identifiers that begin with an underscore and either an uppercase letter or another underscore are always reserved for any use." — Andrew Henle
– Andrew Henle, Commented Sep 7, 2024 at 16:51
Note well that although C can provide a "singleton" in the sense of a distinguished object that all clients are expected to use, it cannot provide a type that inherently prevents more than one instance from being created, in the sense that "singleton" is often used in OO contexts. — John Bollinger
– John Bollinger, Commented Sep 7, 2024 at 17:03
Aside: hiding a pointer inside a typedef is horrible and confusing. For example, you define a function mysharedobj *__instance() but mysharedobj is already a pointer. — pmacfarlane
– pmacfarlane, Commented Sep 7, 2024 at 17:08

John Bollinger · Accepted Answer · 2024-09-07 18:02:48Z

I have a requirement for an OBJECT to be used by other objects. The requirement is that the OBJECT not require initialization by any external call.

If the initial values of all members can be written as constant expressions

... then just declare the object itself, with an initializer:

static struct My_Shared_Obj the_object = { .is_happy = 1, .foos = NULL };

That initialization happens as if before the program ever starts running, so no function can see an uninitialized value.

Within the same translation unit, you can access the object directly. If you want to expose it outside the TU, then also provide an external function to do so:

struct My_Shared_Obj *get_mso(void) {
  return &the_object;
}

Alternatively, if you don't make the variable static then you don't even need an accessor function. Just provide a header that declares it for other TUs as extern, without an initializer:

extern struct My_Shared_Obj the_object;

. Then everyone can access it directly. And if you're considering objecting to using global variables, then do first sit back and have a think about how "singleton" is just another name for that anyway, possibly gussied up with a little lipstick.

If any initial values require run-time computation

... then you need to gate all access to the object via a function that tests whether to initialize it first. In this case, it makes sense to make the structure itself a static local variable of that function, and you can provide another that specifies whether to initialize:

struct My_Shared_Obj *get_mso(void) {
    static struct My_Shared_Obj the_object;
    static _Bool is_initialized;

    if (!is_initialized) {

        // ... initialize the_object ...

        is_initialized = 1;
    }

    return &the_object;
}

Defining the shared object inside the function gives it no linkage, so that even other functions in the same TU can't access it without ultimately going to get_mso() to obtain a pointer to it.

Do note that if you need thread safety then you'll need to do some extra work. There are several way to do that, depending on details of the environments you need to support.

Is [the approach presented in the question] the best way to implement a self-initializing object?

There is no way in C to have a self-initializing object, because in C, objects are data only. They have no behavior.

Also, no, the approach describe is not the best way to implement at-need initialization under the conditions you describe (see above in this answer).

Moreover, this ...

mysharedobj *__instance() {
  if(MSO == NULL) {
    // initialize MSO
  }

  return MSO;
}

... is wrong. Your MSO has type mysharedobj (a.k.a. struct My_Shared_Obj *, confusingly hidden behind a typedef), but the return type of the function is mysharedobj *, which is different. C at least requires a cast, though some compilers might nevertheless do the conversion implicitly and silently. (But do you really not get at least a warning?)

More importantly, if another function uses the pointer returned by that function as the struct My_Shared_Obj ** that the function promises it to be, then undefined behavior results. If you're lucky, the program will crash with a segfault or some similar memory-related error, but it could as easily seem to work as expected, or almost so. You could very easily see surprising behavior if some code uses MSO directly, while other code uses the pointer obtained from __instance().

Reference behavior doesn't seem to make changes to MSO but only for the scope of the function

C does not have references, and "reference behavior" is not a standard part of C jargon. Thus, it's not clear what you expect, but also not clear what you observe. Possibly, though, you're seeing effects of the issue described in my immediately preceding comments.

corrected some typos ... specifically: mysharedobj *__instance() {...}

Collectives™ on Stack Overflow

How to implement singleton object in C?

1 Answer 1

If the initial values of all members can be written as constant expressions

If any initial values require run-time computation

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

If the initial values of all members can be written as constant expressions

If any initial values require run-time computation

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related