To get the value of a pointer, just de-reference the pointer. 

    int *ptr;
    int value;
    *ptr = 9;
    
    value = *ptr;

value is now 9.

I suggest you read more about pointers, this is their base functionality.

I&#39;d like to achieve a custom-colored shape like this using no Javascript:
![3 corner rounded triangle][1]

Currently I&#39;m overlaying an image of the &#39;frame&#39; over an orange rectangular div, but this is pretty hacky.
I suppose I could use a dynamically generated canvas element, but that not only requires JS, but HTML5 canvas support. Any ideas?

  [1]: http://i.stack.imgur.com/YDY9e.png

How to make 3-corner-rounded triangle in CSS

Could you explain this for me please:

    someformobj.BeginInvoke((Action)(() =&gt;
    {
        someformobj.listBox1.SelectedIndex = 0;
    }));

Could you tell me how can I use `begininvoke` exactly?
What is `Action` type?
Why there is blank brackets `()`?
And what does this mean `=&gt;`?

How to use BeginInvoke C#

I was wondering if it&#39;s possible to make a pointer not a pointer..

The problem is I have a function that accepts a pointer for an paramater for me to easily get a value to that pointer. It&#39;s a simple int so I was wondering if I could just get that value without needing to send around a pointer wherever I want the value to land.

I don&#39;t want the function to return the value as an int as it&#39;s giving a value to 2 pointers!

cpp / c++ get pointer value or depointerize pointer

I was wondering if it's possible to make a pointer not a pointer..
The problem is I have a function that accepts a pointer for an paramater for me to easily get a value to that pointer. It's a simple int so I was wondering if I could just get that value without needing to send around a pointer wherever I want the value to land.
I don't want the function to return the value as an int as it's giving a value to 2 pointers!

I am trying to structure my project to include the production sources (in `src` subfolder) and tests (in `test` subfolder). I am using CMake to build this. As a minimal example I have the following files:

CMakeLists.txt:

    cmake_minimum_required (VERSION 2.8) 
    project (TEST) 
    
    add_subdirectory (src) 
    add_subdirectory (test) 

src/CMakeLists.txt:

    add_executable (demo main.cpp sqr.cpp) 

src/sqr.h

    #ifndef SQR_H
    #define SQR_H
    double sqr(double);    
    #endif // SQR_H

src/sqr.cpp

    #include &quot;sqr.h&quot;
    double sqr(double x) { return x*x; }

src/main.cpp  - uses sqr, doesn&#39;t really matter

test/CMakeLists.txt:

    find_package(Boost COMPONENTS system filesystem unit_test_framework REQUIRED)
    
    include_directories (${TEST_SOURCE_DIR}/src) 
    
    ADD_DEFINITIONS(-DBOOST_TEST_DYN_LINK) 
    
    add_executable (test test.cpp ${TEST_SOURCE_DIR}/src/sqr.cpp) 
    
    target_link_libraries(test
                          ${Boost_FILESYSTEM_LIBRARY}
                          ${Boost_SYSTEM_LIBRARY}
                          ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY}
                          )
    
    enable_testing()
    add_test(MyTest test)

test/test.cpp:

    #define BOOST_TEST_MODULE SqrTests
    #include &lt;boost/test/unit_test.hpp&gt;
    
    #include &quot;sqr.h&quot;
    
    BOOST_AUTO_TEST_CASE(FailTest)
    {
    	BOOST_CHECK_EQUAL(5, sqr(2));
    }
    
    BOOST_AUTO_TEST_CASE(PassTest)
    {
    	BOOST_CHECK_EQUAL(4, sqr(2));
    }

A few questions:

 1. Does this structure make sense? What are the best practises when structuring this code? (I am coming from C# and java, and there it is easier in a sense)
 2. I don&#39;t like the fact that I have to list all the files from the `src` folder in the `test/CMakeLists.txt` file. If this was a library project, I would just link the library. Is there a way to avoid listing all the cpp files from the other project?
 3. What are the lines `enable_testing()` and `add_test(MyTest test)` doing? I haven&#39;t seen any effect. How can I run the tests from CMake (or CTest)?
 4. So far I just ran `cmake .` in the root folder, but this created a mess with temporary files everywhere. How can I get the compilation results in a reasonable structure?

CMake: Project structure with unit tests

C++11 allows functions declared with the `constexpr` specifier to be used in constant expressions such as template arguments. There are stringent requirements about what is allowed to be `constexpr`; essentially such a function encapsulates only one subexpression and nothing else. (Edit: this is relaxed in C++14 but the question stands.)

Why require the keyword at all? **What is gained?**

It does help in revealing the intent of an interface, but it [doesn&#39;t][1] validate that intent, by guaranteeing that a function is usable in constant expressions. After writing a `constexpr` function, a programmer must still:

1. Write a test case or otherwise ensure it&#39;s actually used in a constant expression.
2. Document what parameter values are valid in a constant expression context.

Contrary to revealing intent, decorating functions with `constexpr` may add a false sense of security since tangential syntactic constraints are checked while ignoring the central semantic constraint.

---

**In short:** Would there be any undesirable effect on the language if `constexpr` in function declarations were merely optional? Or would there be any effect at all on any valid program?

  [1]: https://stackoverflow.com/q/13295089/153285

Why do we need to mark functions as constexpr?

I&#39;ve read that 

&gt; &quot;Multiple threads can simultaneously read and write different
&gt; shared_ptr objects, even when the objects are copies that share
&gt; ownership.&quot; ([MSDN: Thread Safety in the Standard C++ Library][1])

Does that mean that changing shared_ptr object is safe ?  
For an instance, is the next code considered safe:

    shared_ptr&lt;myClass&gt; global = make_shared&lt;myClass&gt;();
    ...
    
    //In thread 1
    shared_ptr&lt;myClass&gt; private = global;
    ...
    
    //In thread 2
    global = make_shared&lt;myClass&gt;();
    ...

Can I be sure in that case that thread 1 `private` will have the original value of `global` or the new value which thread 2 assigned but either way it will have a valid shared_ptr to myClass?


==EDIT==  
Just to explain my motivation. I want to have a shared pointer to hold my configuration and I have a thread pool to handle requests.  
so `global` is the global configuration.  
`thread 1` is taking the current configuration as it start to handle a request.  
`thread 2` is updating the configuration. (only apply to future requests)  

If it&#39;s work, I can update the configuration that way without breaking it in the middle of a request handling.

  [1]: http://msdn.microsoft.com/en-us/library/c9ceah3b%28v=vs.100%29.aspx

std::shared_ptr thread safety

&gt; **Possible Duplicate:**  
&gt; https://stackoverflow.com/q/3106110

&lt;!-- End of automatically inserted text --&gt;

I recently attended a C++11 seminar and the following tidbit of advice was given.

    when you have &amp;&amp; and you are unsure, you will almost always use std::move

Could any one explain to me why you should use `std::move` as opposed to some alternatives and some cases when you should not use `std::move`?

Why do you use std::move when you have &amp;&amp; in C++11?

**The Problem**

We have a mid-sized program for a simulation task, that we need to optimize. We have already done our best optimizing the source to the limit of our programming skills, including profiling with [Gprof][1] and [Valgrind][2].

When finally finished, we want to run the program on several systems probably for some months. Therefore we are really interested in pushing the optimization to the limits. 

All systems will run Debian/Linux on relatively new hardware (Intel i5 or i7). 

**The Question**

*What are possible optimization options using a recent version of g++, that go beyond -O3/-Ofast?*

We are also interested in costly minor optimization, that will payout in the long run. 

**What we use right now**

Right now we use the following g++ optimization options:

 - `-Ofast`: Highest &quot;standard&quot; optimization level. The included `-ffast-math` did not cause any problems in our calculations, so we decided to go for it, despite of the non standard-compliance.
 - `-march=native`: Enabling the use of all CPU specific instructions.
 - `-flto` to allow link time optimization, across different compilation units.

  [1]: http://en.wikipedia.org/wiki/Gprof
  [2]: http://en.wikipedia.org/wiki/Valgrind

G++ optimization beyond -O3/-Ofast

In a reputable source about C, the following information is given after discussing the `&amp;` operator:

&gt; ... It&#39;s a bit unfortunate that the terminology *[address of]* remains, because it confuses those who don&#39;t know what addresses are about, and misleads those who do: thinking about pointers as if they were addresses usually leads to grief...

Other materials I have read (from equally reputable sources, I would say) have always unabashedly referred to pointers and the `&amp;` operator as giving memory addresses. **I would love to keep searching for the actuality of the matter, but it is kind of difficult when reputable sources KIND OF disagree.**

Now I am slightly confused--what *exactly* is a pointer, then, if not a memory address? 

**P.S.**

The author later says: *...I will continue to use the term &#39;address of&#39; though, because to invent a different one* [term] *would be even worse.*


What exactly is a C pointer if not a memory address?

I did find some questions already on StackOverflow with similar title, but when I read the answers, they were focusing on different parts of the question, which were really specific (e.g. STL/containers).

Could someone please show me, why you must use pointers/references for implementing polymorphism? I can understand pointers may help, but surely references only differentiate between pass-by-value and pass-by-reference?

Surely so long as you allocate memory on the heap, so that you can have dynamic binding, then this would have been enough. Obviously not.

Why doesn&#39;t polymorphism work without pointers/references?

Considering the [following code][1] (and the fact that [`VirtualAlloc()` returns a `void*`][2]):

    BYTE* pbNext = reinterpret_cast&lt;BYTE*&gt;(
        VirtualAlloc(NULL, cbAlloc, MEM_COMMIT, PAGE_READWRITE));

why is `reinterpret_cast` chosen instead of `static_cast`?

I used to think that `reinterpret_cast` is OK for e.g. casting pointers to and from integer types (like e.g. `DWORD_PTR`), but to cast from a `void*` to a `BYTE*`, isn&#39;t `static_cast` OK?

Are there any (subtle?) differences in this particular case, or are they just both valid pointer casts?

Does the C++ standard have a preference for this case, suggesting a way instead of the other?



  [1]: http://blogs.msdn.com/b/oldnewthing/archive/2005/05/19/420038.aspx
  [2]: http://msdn.microsoft.com/en-us/library/windows/desktop/aa366887%28v=vs.85%29.aspx

Proper way of casting pointer types

I&#39;m writing software for an embedded system.  

We are using pointers to access registers of an FPGA device.  
Some of the registers are read-only, while others are write-only.  

The write-only registers will produce undefined values when read.  

I want to define a pointer type that will allow the compiler to detect when reading values from a write-only registers (a.k.a. dereferencing).

Can a write-only pointer be created using only C language syntax?  
(We are developing first prototype using C, but moving to C++ on 2nd generation.)

How can an efficient write-only pointer be created in C++?
(Remember, this is not tracking items in dynamic memory, but accessing hardware addresses.)

This code is used on an embedded system where safety and quality are highest concerns.  


Write-Only pointer type

I am confused about which syntax to use if I want to pass an array of known or unknown size as a function parameter.

Suppose I have these variants for the purpose:

    void func1(char* str) {
        //print str
    }

    void func2(char str[]) {
        //print str
    }

    void func3(char str[10]) {
        //print str
    }

What are the pros and cons of using each one of these?

Content Type	Original Author	Original Content on Stackoverflow
Question	Rasmus	View Question on Stackoverflow
Solution 1 - C++	James McDonnell	View Answer on Stackoverflow

cpp / c++ get pointer value or depointerize pointer

C++ Problem Overview

C++ Solutions

Solution 1 - C++

How to use BeginInvoke C#

How to make 3-corner-rounded triangle in CSS

Attributions