Static cast will also fail if the compiler doesn't know (or is pretending not to know) about the relationship between the types. If your inheritance isn't declared public between the two, the compiler will consider them as unrelated types and give you the same cryptic warning.

This just bit me, so thought I'd share.

You should use reinterpret_cast for casting pointers, i.e.

r = reinterpret_cast<int*>(p);

Of course this makes no sense,

unless you want take a int-level look at a double! You'll get some weird output and I don't think this is what you intended. If you want to cast the value pointed to by p to an int then,

*r = static_cast<int>(*p);

Also, r is not allocated so you can do one of the following:

int *r = new int(0);
*r = static_cast<int>(*p);
std::cout << *r << std::endl;

Or

int r = 0;
r = static_cast<int>(*p);
std::cout << r << std::endl;

A static_cast is not allowed to remove const from the pointed-to type, only const_cast is allowed to do that.

(1) In the conversion:

// pointer to CONST void     pointer to MUTABLE pointer to const int
   const void *          ->  const int **

We are removing the const qualification from the pointed-to type. Without using const_cast to remove constness completely (which is probably not correct), we need to do:

// pointer to CONST void     pointer to CONST pointer to const int
   const void *          ->  const int * const *

// in code:
auto pp = static_cast<const int * const *>(p);

(2) The other conversion:

// pointer to CONST void     pointer to CONST pointer to int
   const void *          ->  int * const *

... is perfectly fine, because we are preserving the const-ness of what was pointed to.

Note: if you are having trouble with figuring out C/C++ type syntax, I recommend using cdecl+, an online tool which converts syntax to English prose.

long *plDog = static_cast<long*>(piDog); // invalid type conversion

Why is my static_cast of a pointer failing?

Because it is ill-formed. None of the rules of static_cast apply to the cast that you're attempting. It is an invalid conversion, as you mention in the comments.

A pointer to one object type may not be static casted to a pointer to another object type unless they are pointers to related classes, or when casting to/from pointer to void.

This reference suggests it should be OK: https://en.cppreference.com/w/cpp/language/static_cast

That reference suggests that the conversion you attempt is not OK.

long* plDog = (long*)(piDog); // this is OK too... very weird!!

This is a well-formed conversion. It's not "weird".

There are many conversions that explicit conversions (also called "cast notation" or "C-style cast") allow, and static casts do not allow. This is because static casts have (at least a semblance of) type safety while explicit conversions essentially ask the compiler to pretend that the type system doesn't exist.

Note that indirecting through plDog and accessing the object would result in undefined behaviour. As you can see, it was a good thing that you got the error.

and we aren't allowed to use this one in our coding standards

This is a good limitation to have. This will make it bit harder for your team to write bugs by mistakenly circumventing the type system.

Issue with Visual Studio C++?

No, the issue is that the program is ill-formed. The compiler is correct to inform you about the bug, and is not required to compile the program.

I recommend asking yourself: Why do you want to, or think that you need to do such cast?

They are completely different types see standard:

3.9.1 Fundamental types [basic.fundamental]

1 Objects declared as characters char) shall be large enough to store any member of the implementation's basic character set. If a character from this set is stored in a character object, the integral value of that character object is equal to the value of the single character literal form of that character. It is implementation-defined whether a char object can hold negative values. Characters can be explicitly declared unsigned or
signed. Plain char, signed char, and unsigned char are three distinct types. A char, a signed char, and an unsigned char occupy the same amount of storage and have the same alignment requirements (basic.types); that is, they have the same object representation. For character types, all bits of the object
representation participate in the value representation. For unsigned character types, all possible bit patterns of the value representation represent numbers. These requirements do not hold for other types. In any particular implementation, a plain char object can take on either the same values as a signed char or an unsigned char; which one is implementation-defined.

So analogous to this is also why the following fails:

unsigned int* a = new unsigned int(10);
int* b = static_cast<int*>(a); // error different types

a and b are completely different types, really what you are questioning is why is static_cast so restrictive when it can perform the following without problem

unsigned int a = unsigned int(10);
int b = static_cast<int>(a); // OK but may result in loss of precision

and why can it not deduce that the target types are the same bit-field width and can be represented? It can do this for scalar types but for pointers, unless the target is derived from the source and you wish to perform a downcast then casting between pointers is not going to work.

Bjarne Stroustrop states why static_cast's are useful in this link: http://www.stroustrup.com/bs_faq2.html#static-cast but in abbreviated form it is for the user to state clearly what their intentions are and to give the compiler the opportunity to check that what you are intending can be achieved, since static_cast does not support casting between different pointer types then the compiler can catch this error to alert the user and if they really want to do this conversion they then should use reinterpret_cast.

If-statements don't make compile-time decisions; the compiler will always check both branches.

You need to create an overloaded write() function, where the default version streams to cout, and which you can overload for specific types (such as char).

Since std::cosh for std::complex<T> is a function template, &std::cosh doesn't make sense to the compiler because std::cosh is not a function, it is a template of family of functions. You need to write another overload to handle this case:

#include <complex> //it is where std::cosh<T> is defined

template<class T>
std::vector<std::complex<T>> cosh(std::vector<std::complex<T>> const & v1)
{
    typedef std::complex<T> cosh_type( std::complex<T> const &);
    return eop(v1, static_cast<cosh_type*>(&std::cosh<T>) );
}

By the way, pass the argument by reference to avoid unnecessary copies.

Hope that helps.

static_cast does not check validity at runtime; if the cast compiled, it assumes at runtime that the conversion is okay. If you aren't casting a null pointer, the result of a static_cast will not be a null pointer. To get a checked cast you need dynamic_cast and that, in turn, requires the pointer being converted to point to a polymorphic type, i.e., one that has at least one virtual function. That means changing Component to have at least one virtual function.

There's one star to much. void* can already hold any pointer, without casts:

int main()
{
    A* a = new A(10);
    void* p;
    p = &a;
    return 0;
}

This works for multiple levels, even:

int main()
{
    A* a = new A(10);
    A** aa = &a;
    A*** aaa = &aa;
    void* p = &aaa;
}

This works because A*** is a pointer to a A**.

Thanks Alf.

The fix is to reorder it so the child class definition follows its parent:

#include <stdio.h>

class Parent
{

};

class Child : public Parent
{
public:
    void m();
};

void Child::m()
{
    Parent* p1 = (Parent*)this;
    Parent* p2 = static_cast<Parent*>(this);
}

The reason (or, "excuse," if you prefer) for my mistake is that I mostly program in Java, and haven't done enough C++ to remember my basics. The roughly comparable code in Java, below, does work.

public class Main
{
    public static void main(String[] args)
    {
        Child c = new Child();
    }
}

class Child extends Parent
{
    public void m()
    {
        Parent p = this;
    }
}

class Parent
{

}

I appreciate the help. Kind of puzzled that I had to compile it to get the error message that really mattered. One would expect the IDE to have noticed this. Because it was flagging an error, I never even thought of compiling it. Will remember that for the future.

Cheers!

The reason is most likely that the definition of Node is not visible to the compiler (e.g., it may have been only forward-declared: class Node;).

Self-contained example:

class Base {};

class Derived; // forward declaration

Base b;

Derived * foo() {
    return static_cast<Derived*>( &b ); // error: invalid cast
}

class Derived : public Base {}; // full definition

Derived * foo2() {
    return static_cast<Derived*>( &b ); // ok
}

For static_cast,

Converts between types using a combination of implicit and user-defined conversions.

User-defined conversion will be considered, but you're casting to int on const object, you should make operator int() const member function:

operator int() const {
               ~~~~~
    ...
}

For reinterpret_cast,

Converts between types by reinterpreting the underlying bit pattern.

Unlike static_cast, but like const_cast, the reinterpret_cast expression does not compile to any CPU instructions. It is purely a compiler directive which instructs the compiler to treat the sequence of bits (object representation) of expression as if it had the type new_type.

So reinterpret_cast<int>(x) won't work anyhow, and user-defined conversion won't be considered.

You did not invoke the length method. You should use int size=static_cast<int>(s.length());: notice the call operator at the end of the length method name.

However, if by doing this, you are trying to convert the string to an integer, this is wrong. This only gives you the number of characters in the string.