title: static_cast from 'const unsigned char *const *' to 'const char *const *' is not allowed
body: <p>What I'm experiencing is the refusal of my compiler to cast my unsigned char pointer to a signed char pointer. I got confused for a little while, because I had been using static_cast to convert signedness for the <em>longest time</em>.</p>
  
  <p>Then I did a little digging (well, it wasn't very deep. I did a little scooping!) and even though now I understand that the prevention of pointer type casting by <code>static_cast</code> is precisely the reason why it's the safer and better way to cast (than the traditional alternatives which may invoke implementation defined behavior or undefined behavior), I'm still not sure what I should actually do for my situation. </p>
  
  <p>What I have here is a call to an OpenGL API function whose signature is </p>
  
  <pre><code>void glShaderSource(
      GLuint shader, GLsizei count, const GLchar **string, const GLint *length
  );
  </code></pre>
  
  <p>I recently changed the file reader API so that instead of returning the data read from a file as a <code>char *</code>, I do it now with an <code>unsigned char *</code>. This change was not made in error as I feel that an unsigned char is a much better handle to raw data (even though it may well be ASCII data), and indeed <code>void *</code> might be even more clear in this regard.</p>
  
  <p>And then of course I'll be passing the address of this pointer in as the third arg to <code>glShaderSource</code>. </p>
  
  <p>I reckon that it's safe for me to just do the C-style cast to <code>GLchar**</code>, and in fact that is probably the standard answer for this situation. Using <code>reinterpret_cast</code> would just be going above and beyond, but admittedly by only a small amount.</p>
  
  <p>But I'd like to maybe find out a bit more about what the thought process is supposed to be in this situation. <em>Why</em> is it exactly that I am able to dismiss the signedness of the chars at stake here? Is it simply that since I don't expect to ever write a shader that has the high bit set on any of its characters that means I can cast it?</p>
  
  <p>What if i was facing a situation with signed/unsigned integers, and there really are dire consequences of spurious negative integer values becoming interpreted as large positive values? How can I write code here to try to be "safe" about it?</p>
  
  <p>My instinct is telling me that this is obviously impossible without implementing code that actually goes and observes the data itself instead of passing the pointer, so is there just no way to regain the safety of <code>static_cast</code> in this situation, since i'm being forced to work with pointers. </p>