<?xml version="1.0" encoding="UTF-8" ?>
<?xml-stylesheet type="text/xsl" href="https://community.arm.com/utility/feedstylesheets/rss.xsl" media="screen"?><rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:slash="http://purl.org/rss/1.0/modules/slash/" xmlns:wfw="http://wellformedweb.org/CommentAPI/"><channel><title>Restrict Global Variables to specific modules</title><link>https://community.arm.com/developer/tools-software/tools/f/keil-forum/39755/restrict-global-variables-to-specific-modules</link><description> 
Here comes a very special wish - please do not call me crazy: 

 
Working with many C modules, I prefer to define
protected/&amp;quot;dangerous&amp;quot; variables static to one module. Quite often I
would like to have a variable global only in a restricted number of</description><dc:language>en-US</dc:language><generator>Telligent Community 10</generator><item><title>RE: Restrict Global Variables to specific modules</title><link>https://community.arm.com/thread/154798?ContentTypeID=1</link><pubDate>Tue, 05 Jun 2012 09:04:18 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:c278b458-7f27-4621-81da-b78baf39cc47</guid><dc:creator>ImPer Westermark</dc:creator><description>&lt;p&gt;&lt;p&gt;
If you put PLL initialization inside main(), then you know the
global objects will be constructed before the PLL is initialized.&lt;/p&gt;

&lt;p&gt;
But an assembler startup file will not initialize any global C++
objects randomly. So you can spend whatever time you want setting up
PLL etc before you let the startup script call the functions that
initializes variables, constructs objects etc.&lt;/p&gt;

&lt;p&gt;
You may get an initial copy of a startup file when you create a
project. But after that, you own that file. You can do whatever you
like with it, before you let it call the finial init function(s) that
setups the runtime library, global variables etc before main() is
called.&lt;/p&gt;
&lt;/p&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item><item><title>RE: Restrict Global Variables to specific modules</title><link>https://community.arm.com/thread/154797?ContentTypeID=1</link><pubDate>Tue, 05 Jun 2012 09:00:26 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:60d1a7dd-7992-4470-bc36-a05aa17648d7</guid><dc:creator>ImPer Westermark</dc:creator><description>&lt;p&gt;&lt;p&gt;
But you have realized that the ARM processor don&amp;#39;t care much about
global memory or stack memory - so you can create objects on the
stack?&lt;/p&gt;

&lt;p&gt;
You can even do something like:&lt;/p&gt;

&lt;pre&gt;
void main(void) {
    if (configured_as_x) {
        CFunctionality1 app;
        app.Run();
    } else {
        CFunctionality2 app;
        app.Run();
    }
}
&lt;/pre&gt;
&lt;/p&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item><item><title>RE: Restrict Global Variables to specific modules</title><link>https://community.arm.com/thread/154285?ContentTypeID=1</link><pubDate>Tue, 05 Jun 2012 08:48:08 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:2fe2c580-9ff1-4162-8d4f-db602cf1527f</guid><dc:creator>nice day</dc:creator><description>&lt;p&gt;&lt;p&gt;
But this reply is not very precise.&lt;/p&gt;

&lt;p&gt;
If you say, that the &amp;quot;constructor will be called before main&amp;quot;...
You know that in an ARM software quite a bit is happening before
main, especially all the core initialisation and the PLL clock
startup. Can I be sure, that the compiler will be smart enough to
call such global constructors after the basic core initialisation and
PLL clock startup code? (how should the compiler recognize this code
...?)&lt;/p&gt;
&lt;/p&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item><item><title>RE: Restrict Global Variables to specific modules</title><link>https://community.arm.com/thread/154276?ContentTypeID=1</link><pubDate>Tue, 05 Jun 2012 08:44:02 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:4745fe0d-f234-4a32-b995-5981d70f485f</guid><dc:creator>nice day</dc:creator><description>&lt;p&gt;&lt;p&gt;
ok ok you are starting to convince me ...&lt;/p&gt;

&lt;p&gt;
but do you perhaps also have an answer on my new question?
(possibility to define the exact time point, when the constructor of
a global class is called? - if I cannot influence this, I would
prefer to somehow not allow constructors for global classes ... (in
Windows programming this is one of the rules: never use a global
class, otherwise you might run in strange problems ... if here I HAVE
TO use global classes (at least for the classes with much data,
because I do not want dynamic memory allocation), then I would at
least like to have this &amp;quot;global class constructor problem&amp;quot; under
tight control))).&lt;/p&gt;
&lt;/p&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item><item><title>RE: Restrict Global Variables to specific modules</title><link>https://community.arm.com/thread/153686?ContentTypeID=1</link><pubDate>Tue, 05 Jun 2012 08:42:17 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:823d596c-b2a9-49d0-88d6-35b19cd2ab18</guid><dc:creator>ImPer Westermark</dc:creator><description>&lt;p&gt;&lt;p&gt;
A global class? A class is a data type. As expert C++ programmer,
I would have expected you to talk about a global object - i.e. an
instantiation of a class.&lt;/p&gt;

&lt;p&gt;
Well - the startup code have to make sure that the constructor is
called before the code enters main(). Just as the startup code have
to make sure that the interval variables in the C library gets
initial values after the startup code have mapped RAM but before you
reach main().&lt;/p&gt;

&lt;p&gt;
If you want the constructor to be called after you enter main(),
then you should create the object as an auto object on the stack.
That allows main() to contain code that makes decisions before the
constructor is called. So you could decide what parameters to send to
the constructor.&lt;/p&gt;
&lt;/p&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item><item><title>RE: Restrict Global Variables to specific modules</title><link>https://community.arm.com/thread/153694?ContentTypeID=1</link><pubDate>Tue, 05 Jun 2012 08:30:54 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:858f0179-f212-4c0a-8608-c64134656fad</guid><dc:creator>ImPer Westermark</dc:creator><description>&lt;p&gt;&lt;p&gt;
But if your #pragma only handles the next variable declaration,
you could need a huge number of #pragma - and each one can be
wrong.&lt;/p&gt;

&lt;p&gt;
Think about C++ which can use { and } to group information into a
namespace or class. Or have private:, public:, protected: to have
lots of things into a specific access category.&lt;/p&gt;

&lt;p&gt;
If you think dynamic allocation of objects is a requirement to get
the full power of C++, then you may have used C++, but you have not
considered the full richness of the language compared to C.&lt;/p&gt;

&lt;p&gt;
Think about a circular buffer with enquque(), dequeue(),
is_empty(), is_full(), have_data(). Duplicated multiple times for
multiple serial ports. And having the constructor receive a pointer
to a char buffer and a buffer size. So you can instantiate -
statically - multiple ring buffers of different size, for UART0
receive, UART0 transmit, UART1 receive, UART1 transmit, ..., SPI0
receive, SPI0 transmit, ... Zero dynamic memory involved. Unless you
decide that you have one big block of buffer memory, and a
configuration table to decide how many bytes of the pool for UART0
receive, UART0 transmit, ...&lt;/p&gt;

&lt;p&gt;
Or let&amp;#39;s say that you have a class with a state machine supporting
different sets of blinks - slow, fast, dual-blink, ... And a virtual
method for driving an output. So you have one instance driving LED-1,
one for LED-2, one for REL-1, one for REL-2, ... And the code runs
through all these objects (accessed as an array of pointers) and call
an update() method - automagically getting all your blinks etc. No
dynamic memory involved. With C, you would have to send a pointer to
a struct containing configuration and current tick counters, and a
function pointer for what output to drive.&lt;/p&gt;

&lt;p&gt;
Dynamic memory is for solving problems where you don&amp;#39;t know how
many of something you need. But with limited RAM, you can&amp;#39;t just
allocate more objects. So there must be limits. And limits means that
the problem could have been solved statically. Or that you know that
you either need x objects of type 1, or y objects of type 2 - but not
at the same time. C or C++ doesn&amp;#39;t matter. You still have to write
the software based on the existing hw - and select the used hw based
on needs. But operator new is not what &amp;quot;makes&amp;quot; C++. The main purpose
of it is to allow many programs to share a big processor and have
each individual program claim no more than what is needed. With
smaller microcontrollers, there are only one program running. So no
memory to save for another program. So rules for how to share the
available RAM can be decided at design time - without hurting the
capabilities of the programming language.&lt;/p&gt;
&lt;/p&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item><item><title>RE: Restrict Global Variables to specific modules</title><link>https://community.arm.com/thread/153009?ContentTypeID=1</link><pubDate>Tue, 05 Jun 2012 08:23:25 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:cc080711-7dce-4e7b-9b86-c5988ca0d972</guid><dc:creator>nice day</dc:creator><description>&lt;p&gt;&lt;p&gt;
One further point:&lt;/p&gt;

&lt;p&gt;
If I use a global class in Keil ARM C++, and if this class has a
constructor - is there some way to tell the compiler when the
constructor should be called? (I mean e. g. somewhere in the
assembly-startup function, in the c-startup function, or at the start
of the main function?)&lt;/p&gt;
&lt;/p&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item><item><title>RE: Restrict Global Variables to specific modules</title><link>https://community.arm.com/thread/153008?ContentTypeID=1</link><pubDate>Tue, 05 Jun 2012 07:47:14 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:a0220e29-34e8-4a3d-b6b8-81fd1ba5595b</guid><dc:creator>nice day</dc:creator><description>&lt;p&gt;&lt;p&gt;
&lt;b&gt;And that you haven&amp;#39;t spent any real time with C++ and don&amp;#39;t
know the real strengths with the language.&lt;/b&gt;&lt;/p&gt;

&lt;p&gt;
Sorry, but that&amp;#39;s not right - in Windows I am C++ expert and
fan.&lt;/p&gt;

&lt;p&gt;
I am far from rewriting C language. I just wanted to add a helpful
programming aid to the linker.&lt;/p&gt;
&lt;/p&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item><item><title>RE: Restrict Global Variables to specific modules</title><link>https://community.arm.com/thread/152259?ContentTypeID=1</link><pubDate>Tue, 05 Jun 2012 07:32:10 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:ef4a5c91-1e1c-474a-bb2b-0e598ee5eea8</guid><dc:creator>ImPer Westermark</dc:creator><description>&lt;p&gt;&lt;p&gt;
You are wrong if you think dynamic memory is what it takes to get
huge advantages from C++.&lt;/p&gt;

&lt;p&gt;
C++ don&amp;#39;t have more need for dynamic memory than C has. If you
receive data in a C program, you need somewhere to store it.
Switching to C++, you still need somewhere to store it. It doesn&amp;#39;t
matter if a variable is a C++ object, or an int or an array of
char.&lt;/p&gt;

&lt;p&gt;
The main power of C++ is in encapsulation, and creating tight (but
extendable) modules combining data and methods. And encapsulation
don&amp;#39;t have anything to do with how objects are instantiated.&lt;/p&gt;

&lt;p&gt;
What we do know, right now, is that you want to rewrite the C
language because you aren&amp;#39;t happy with it.&lt;/p&gt;

&lt;p&gt;
And that you haven&amp;#39;t spent any real time with C++ and don&amp;#39;t know
the real strengths with the language.&lt;/p&gt;

&lt;p&gt;
So - time that you start investing some time really learning the
language. And thinking about _why_ things looks like they do.&lt;/p&gt;

&lt;p&gt;
Consider how classes can have friends.&lt;br /&gt;
Consider the implications of &amp;quot;using&amp;quot; namespaces.&lt;br /&gt;
Or the advantages of type-safe linking.&lt;br /&gt;
Or the ability to use { and } to encapsulate a block of code marked
as &amp;quot;C&amp;quot;.&lt;br /&gt;
The difference in complexity compared to your #pragmas are huge.&lt;/p&gt;
&lt;/p&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item><item><title>RE: Restrict Global Variables to specific modules</title><link>https://community.arm.com/thread/152262?ContentTypeID=1</link><pubDate>Tue, 05 Jun 2012 06:23:00 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:4242c502-4d92-438b-922c-6a54fa0e9c0d</guid><dc:creator>Tamiryan Michael</dc:creator><description>&lt;p&gt;&lt;p&gt;
&lt;i&gt;And the power of C++ mainly comes up, if you start with dynamic
memory handling.&lt;/i&gt;&lt;/p&gt;

&lt;p&gt;
No this is not the case at all !&lt;/p&gt;
&lt;/p&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item><item><title>RE: Restrict Global Variables to specific modules</title><link>https://community.arm.com/thread/154286?ContentTypeID=1</link><pubDate>Tue, 05 Jun 2012 05:45:44 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:87dab02d-2b07-44fc-88d9-7844d60a7ede</guid><dc:creator>ImPer Westermark</dc:creator><description>&lt;p&gt;&lt;p&gt;
Constructors/destructors aren&amp;#39;t bound to the use of &amp;quot;new&amp;quot; and
&amp;quot;delete&amp;quot;.&lt;/p&gt;

&lt;p&gt;
They apply just as well to global objects, or objects created on
the stack.&lt;/p&gt;

&lt;p&gt;
You want to make classes complete - and that would include the use
of constructors/destructors. Of course, some classes don&amp;#39;t define
anything that need destruction in which case you can get by with an
empty default destructor.&lt;/p&gt;

&lt;p&gt;
But just as global C variables are always zeroed, you want all C++
objects (however they are created) to have a known state of all
member attributes. Unless you think it&amp;#39;s fun to debug programs having
uninitialized variables taking random values depending on what was in
memory before.&lt;/p&gt;
&lt;/p&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item><item><title>RE: Restrict Global Variables to specific modules</title><link>https://community.arm.com/thread/151477?ContentTypeID=1</link><pubDate>Tue, 05 Jun 2012 05:39:58 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:f12dc56b-ad67-4da9-aacb-0d5a9b67a515</guid><dc:creator>nice day</dc:creator><description>&lt;p&gt;&lt;p&gt;
Thank you for the link to the two ARM C++ examples. Really
interesting.&lt;/p&gt;

&lt;p&gt;
But the point that they present only 2 very basic examples with
C++ in a folder which contains hundred&amp;#39;s of C examples does not
really support the importance of C++ in microcontroller programming
:).&lt;/p&gt;

&lt;p&gt;
I think the most important thing is (concening my programming
method), that I do not use dynamic memory handling in uC programming.
And the power of C++ mainly comes up, if you start with dynamic
memory handling.&lt;/p&gt;

&lt;p&gt;
In Windows programming nearly anything is dynamic memory - there I
never would dare to write larger software without C++.&lt;/p&gt;

&lt;p&gt;
But I think without dynamic memory, C++ looses much of its
glamour.&lt;/p&gt;
&lt;/p&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item><item><title>RE: Restrict Global Variables to specific modules</title><link>https://community.arm.com/thread/150817?ContentTypeID=1</link><pubDate>Tue, 05 Jun 2012 05:27:11 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:385691a7-e3c8-43d3-b981-42a0dcc2e38f</guid><dc:creator>Andy Neil</dc:creator><description>&lt;p&gt;&lt;p&gt;
You must live a very sheltered life!&lt;/p&gt;

&lt;p&gt;
There have been C++ compilers for microcontrollers for very many
years - even for the 8051!!&lt;/p&gt;

&lt;p&gt;
I would suggest that you seek out a &lt;b&gt;training provider&lt;/b&gt; to
help you lay some proper, good foundations...&lt;/p&gt;

&lt;p&gt;
eg, some are mentioned here:&lt;/p&gt;

&lt;p&gt;
&lt;a href="http://www.keil.com/events/links.asp"&gt;http://www.keil.com/events/links.asp&lt;/a&gt;&lt;br /&gt;

&lt;a href="http://blog.antronics.co.uk/2011/08/08/"&gt;blog.antronics.co.uk/.../&lt;/a&gt;
(although it&amp;#39;s talking about &amp;#39;C&amp;#39;, the providers mentioned also do
C++).&lt;/p&gt;

&lt;p&gt;
Dan Saks writes a lot about C++ in embedded systems: &lt;a href="http://www.dansaks.com/"&gt;http://www.dansaks.com/&lt;/a&gt;&lt;/p&gt;
&lt;/p&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item><item><title>RE: Restrict Global Variables to specific modules</title><link>https://community.arm.com/thread/153016?ContentTypeID=1</link><pubDate>Tue, 05 Jun 2012 05:20:23 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:67b71164-1f61-46e7-b606-fa970b1e282c</guid><dc:creator>Gp F</dc:creator><description>&lt;p&gt;&lt;p&gt;
an example using STL is located in:&lt;/p&gt;

&lt;pre&gt;
C:\Keil\ARM\Examples\C++\Example1
&lt;/pre&gt;

&lt;p&gt;
another simple example using operator overloading and friend
functions can be found in:&lt;/p&gt;

&lt;pre&gt;
C:\Keil\ARM\Examples\C++\Example2
&lt;/pre&gt;
&lt;/p&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item><item><title>RE: Restrict Global Variables to specific modules</title><link>https://community.arm.com/thread/153696?ContentTypeID=1</link><pubDate>Tue, 05 Jun 2012 05:17:05 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:b541d80d-4f0e-44f4-9024-cb1e0a3f5fc4</guid><dc:creator>nice day</dc:creator><description>&lt;p&gt;&lt;p&gt;
&lt;b&gt;What you have to realize is that the operator &amp;quot;new&amp;quot; isn&amp;#39;t the
only way to get object variables in C++.&lt;/b&gt;&lt;/p&gt;

&lt;p&gt;
That&amp;#39;s what I meant with my statement &amp;quot;I would presumably use C++
in a sort of quasi-static approach&amp;quot;.&lt;/p&gt;

&lt;p&gt;
If I skip new, then usually I would define all my classes global.
And in this case of course it will not make much sense to use
constructor / destructor functions. So the main advantage of using
C++ then will restrict to the variable protection scheme of C++,
which of course is very advanced.&lt;/p&gt;

&lt;p&gt;
... perhaps in some future I will try some small steps with some
simple global C++ classes without constructor / destructor ...&lt;/p&gt;
&lt;/p&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item><item><title>RE: Restrict Global Variables to specific modules</title><link>https://community.arm.com/thread/153012?ContentTypeID=1</link><pubDate>Tue, 05 Jun 2012 05:02:12 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:2381e1d4-0369-43ce-9ed2-ce483941228c</guid><dc:creator>ImPer Westermark</dc:creator><description>&lt;p&gt;&lt;p&gt;
Classes are for C++ - not assembler.&lt;/p&gt;

&lt;p&gt;
So you will obviously not play around with any classes in the
startup file.&lt;/p&gt;

&lt;p&gt;
You don&amp;#39;t need static member methods. But you should think twice
about how you allocate your objects. If they are global objects. Or
created on the stack. Or from a special memory pool. Or from standard
heap. Or if you are going to use something else.&lt;/p&gt;

&lt;p&gt;
What you have to realize is that the operator &amp;quot;new&amp;quot; isn&amp;#39;t the only
way to get object variables in C++.&lt;/p&gt;
&lt;/p&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item><item><title>RE: Restrict Global Variables to specific modules</title><link>https://community.arm.com/thread/152260?ContentTypeID=1</link><pubDate>Tue, 05 Jun 2012 04:56:11 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:1708f941-41d9-4b0e-8463-cab40fe86193</guid><dc:creator>nice day</dc:creator><description>&lt;p&gt;&lt;p&gt;
So you would recommend to keep the assemply and C startup code
from the basic example, and then start with the classes only in the
main function and above?&lt;/p&gt;

&lt;p&gt;
I agree with you, that I anyway would not dare to include too much
dynamic memory handling into the controller software.&lt;/p&gt;

&lt;p&gt;
So then I would mainly use the C++ classes in a sort of
quasi-static approach (possibly even with most member functions
static ...).&lt;/p&gt;

&lt;p&gt;
Just for now I think this is a bit too much for me, I have to
think about it some time.&lt;/p&gt;

&lt;p&gt;
Anyway it would be nice, if Keil could present some simple C++
demo, maybe based on Blinky, to show the advantages and possible
pitfalls of C++ concerning controller programming.&lt;/p&gt;
&lt;/p&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item><item><title>RE: Restrict Global Variables to specific modules</title><link>https://community.arm.com/thread/151473?ContentTypeID=1</link><pubDate>Tue, 05 Jun 2012 04:47:56 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:8b718e88-547a-424c-a6fa-1b78ce7aacf4</guid><dc:creator>ImPer Westermark</dc:creator><description>&lt;p&gt;&lt;p&gt;
STL with lots of dynamic memory etc may not be a good choice.&lt;/p&gt;

&lt;p&gt;
And it may be a good idea to stay away from streams etc also, to
keep down on size of linked libraries.&lt;/p&gt;

&lt;p&gt;
But C++ instead of C really doesn&amp;#39;t matter much to a
microcontroller as general as the ARM. You can write your programs as
C programs with objects. Or C programs with namespaces. Or C programs
with references. Or C programs with exceptions.&lt;/p&gt;

&lt;p&gt;
Good or bad experiences aren&amp;#39;t really caused by the language, but
how the user decides to use the language.&lt;/p&gt;

&lt;p&gt;
The main requirement for the processor is that it should have a
full set of instructions for work through pointers, allowing good
mapping of the &amp;quot;this&amp;quot; pointer that is a very important part of
object-oriented C++ code.&lt;/p&gt;
&lt;/p&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item><item><title>RE: Restrict Global Variables to specific modules</title><link>https://community.arm.com/thread/146871?ContentTypeID=1</link><pubDate>Tue, 05 Jun 2012 04:24:56 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:acaa3eac-ace2-4612-a871-27cff3c4b9b2</guid><dc:creator>nice day</dc:creator><description>&lt;p&gt;&lt;p&gt;
... sorry ... last message should say &amp;quot;I would NOT like to start
from the scratch ...&amp;quot;.&lt;/p&gt;
&lt;/p&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item><item><title>RE: Restrict Global Variables to specific modules</title><link>https://community.arm.com/thread/145332?ContentTypeID=1</link><pubDate>Tue, 05 Jun 2012 04:23:14 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:e8a8d398-2d89-41b1-aa69-9d5968e17c15</guid><dc:creator>nice day</dc:creator><description>&lt;p&gt;&lt;p&gt;
I just looked through the product page, and to my surprise it
really seems to support C++ completely. ... .&lt;/p&gt;

&lt;p&gt;
Just e. g. for my demo board MCBSTM32F400 I did not find any C++
code - also I never saw any uController project in C++ up to now -
this is completely new to me. Therefore I really would be interested
if somebody has used C++ already for uController development, and
what the experiences are (I would like to start &amp;quot;from the scratch&amp;quot; -
too much respect concerning the pitfalls of uController
programming).&lt;/p&gt;
&lt;/p&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item><item><title>RE: Restrict Global Variables to specific modules</title><link>https://community.arm.com/thread/143184?ContentTypeID=1</link><pubDate>Tue, 05 Jun 2012 03:45:53 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:e3bf9fcc-05b0-4fe0-9b21-14c3b2373dee</guid><dc:creator>ImPer Westermark</dc:creator><description>&lt;p&gt;&lt;p&gt;
&amp;quot;Normal&amp;quot; and &amp;quot;state-of-the-art&amp;quot; need not be the same thing.&lt;/p&gt;

&lt;p&gt;
Most people do _not_ want to use a &amp;quot;state-of-the-art&amp;quot; chip - that
would often be a too expensive solution. Why use a $10,000,000 car to
drive to/from work, just because it is state-of-the-art?&lt;/p&gt;

&lt;p&gt;
Haven&amp;#39;t you already been recommended to use C++, in case you need
encapsulation? Why not evaluate it yourself instead of trying to ask
other what they - based on their completely different experience and
needs - think about using it?&lt;/p&gt;
&lt;/p&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item><item><title>RE: Restrict Global Variables to specific modules</title><link>https://community.arm.com/thread/143182?ContentTypeID=1</link><pubDate>Tue, 05 Jun 2012 02:22:52 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:e1b7aa38-273c-40c5-8b38-322f72879409</guid><dc:creator>Andy Neil</dc:creator><description>&lt;p&gt;&lt;p&gt;
Just look at the description on the &lt;b&gt;Product&lt;/b&gt; page...&lt;/p&gt;
&lt;/p&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item><item><title>RE: Restrict Global Variables to specific modules</title><link>https://community.arm.com/thread/140282?ContentTypeID=1</link><pubDate>Tue, 05 Jun 2012 01:55:06 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:e284376a-13dc-4bfc-9da2-9f62dd081b4f</guid><dc:creator>nice day</dc:creator><description>&lt;p&gt;&lt;p&gt;
I just want to use &amp;quot;normal&amp;quot; (=state of the art) Microcontroller.
And I need a very good compiler like Keil.&lt;/p&gt;

&lt;p&gt;
Is it possible to use C++ with Keil - would you recommend it?&lt;/p&gt;
&lt;/p&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item><item><title>RE: Restrict Global Variables to specific modules</title><link>https://community.arm.com/thread/136795?ContentTypeID=1</link><pubDate>Tue, 05 Jun 2012 00:42:09 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:2aef316c-9a2b-452e-abfa-52e21e9b3ac9</guid><dc:creator>Tamiryan Michael</dc:creator><description>&lt;p&gt;&lt;p&gt;
I&amp;#39;m not sure something like an MPU suits your needs...?&lt;/p&gt;
&lt;/p&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item><item><title>RE: Restrict Global Variables to specific modules</title><link>https://community.arm.com/thread/127548?ContentTypeID=1</link><pubDate>Tue, 05 Jun 2012 00:30:06 GMT</pubDate><guid isPermaLink="false">dd9e70c8-6d3c-4c71-b136-2456382a7b5c:58825981-b06b-4286-88ca-e471dbdde7d3</guid><dc:creator>ImPer Westermark</dc:creator><description>&lt;p&gt;&lt;p&gt;
That depends on project and needs.&lt;/p&gt;
&lt;/p&gt;&lt;div style="clear:both;"&gt;&lt;/div&gt;</description></item></channel></rss>