How to Declare an Uninitialised Variable

[Ttelmah]

Sorry, but _incorrect_. The manual, and the C 'bible' are quite explicit.

First, look at the 'static' entry in the manual. Says:

"Variable is globally active and initialized to 0.". Note the 'initialized'.

Then read K&R. "The C programming language":

"In the absence of explicit initialisation, external and static variables are guaranteed to be initialised to zero, automatic and register variables are uninitialised, and have undefined (i.e. garbage) initial values."

C, is quite explicit, that variables that are _not_ initialised explicitly, and are not static or extern, are left uninitialised. CCS has followed this to the letter.

Best Wishes

[lukeevanslx]

[Ttelmah]

As I said:

"automatic and register variables are uninitialised"
There is no such thing as an 'uninitialised static variable'.

Pretty explicit.

[lukeevanslx]

You are right.
My bad. It is what is done with static variables that are not explicitly initialised that is not explicitly specified. And that is the whole point of the thread.

[Ttelmah]

[temtronic]

Ok, I'm at a loss to understand WHY you would want to have an uninitialised variable.(the original thread.)
It seems really,really BAD programming to NOT set variables to a KNOWN condition before 'main' runs unless you want some kind of random data.Perhaps someone can explain why you want this ?
Getting old but always willing to learn!

[Ttelmah]

The key for myself (one of the people who uses this), is to initialise them _myself_, only when the start conditions warrant it.

You use 'restart_cause', and check for this being a 'power up', and then call your own code to initialise all variables the way you want them. However if the cause is 'watchdog timeout', you can carry on with the code, without re-initialising, and hopefully retain values. Similarly one of the other posters tests for the cause being a press of the reset button, not 'power up', and can then use this to allow code to continue.
Yes, you _must_ at some point initialise the variables, _but_ it is quite common to not want this to happen if the code is restarting, but the processor has not switched off.

Best Wishes

[FvM]

A typical motivation for uninitialized global variables is to have them keep the value across a processor reset.

With CCS C, all regular global variables are uninitialized unless you specify a #zero_ram "preprocessor" command. This is in contrast to the behaviour of most (all?) other C-compilers that zero global variables at startup.

Because variables with arbitrary initial value are a popular cause of erratic application behaviour, I would normally suggest to use the #zero_ram command. If you want some variables to keep it's value across resets, you have to refer to explicite initialization of all variables that need it.

Alternatively, you can keep using #zero_ram, #reserve a RAM range and access the data in it through pointers. This is also the typical method with a regular C-compiler that doesn't provide specific means for uninitialized variables.

P.S.: One more point

[asmboy]

[temtronic]

ok...I see how and why you're using this 'feature' but it's a tad scary as a future version of the compiler might 'correct' the 'flaw'(not resetting variables when CPU is reset) and then it's back to recoding the programs to run with the newer compiler.

[Ttelmah]

[FvM]

[Ttelmah]

C is quite explicit, that 'automatic' variables must not be initialised.
Hence standard variables declared in the 'main', must always be left uninitialised.
CCS allows the one 'extra', that global variables are also not initialised, but you don't have to use these.

You can refer to a variable declared in main, from any routine that is called by main, just as if it is global, by using the syntax main.variable_name.
This is why I originally said to declare the variables in the main, for which leaving them uninitialised is then a totally standard feature.

ANSI, does allow you _not_ to initialise the globals. It requires that initialisation of uninitialised globals _must_ be carried out by the loader, not the program itself. Hence you can replace this, and have the code not initialise the variables in certain circumstances. This is standard programming for PC applications that recover from a watchdog reboot.
Since CCS does not have a loader, but only the program, it is correct for it not to initialise these.

Best Wishes

[FvM]

[Ttelmah]

Read the section on initialisation in K&R.
It does _not_ require global's to be initialised. It only requires static variables to be initialised.
Initilalisation in K&R, is generally left as processor dependant, if not specified.
ANSI, changed things, requiring that global's if not explicitly initilalised, should be initialised, but explicitly required this to be done for global's before the program code itself, as part of the 'loader' (definition of this is left vague..). However provision exists in compiler's, to 're-write' this part. If you are running a PC, then you are almost certainly using C code, that relies on this. The BIOS on a PC, is 99% written in C, and quite large lumps of this rely on being able to relaunch sections, with their variables retained (I wrote some of them).
The same is true of quite a bit of the driver code used at low level inside the OS's as well.
The difference in CCS, is that the default behaviour is to not initialise. Effectively the standard would be for #ZERO_RAM to be the default behaviour, with an option to turn this off, while in CCS it is the opposite way round.

Best Wishes