Improve company productivity with a Business Account.Sign Up

  • Status: Solved
  • Priority: Medium
  • Security: Public
  • Views: 750
  • Last Modified:

String literal converted to char*

Hi All

I am getting this warning while compiling my code.

String literal converted to char*

How can I remove this warning? I need to have solution for both Solaris and windwos machines. I am using Sun Workshop compiler on Solaris and Visual studio on Windows.

  • 5
  • 3
  • 3
  • +2
2 Solutions
Hi avi_india,

Post some code ... If you are simply assigning addresses, then changing the char * variable to const char * might be some help ....

OTOH if you are writing to a string literal, expect the program to crash ... You will have to change some code to copy the string literal into writable memory (like statically allocated array of dynamically allocated block of memory)

avi_indiaAuthor Commented:
changing the char * variable to const char *  does help. But I  have got this code from my custome and has millions of line of code. This is a trivial warning. I just need a way to supress this warning.

Cant change char * to const char * using typecast as this will involve changing too many lines of code. As we do not care about this warning, we just need a way to supress this.

Check your compiler documentation ... There might be a flag to supress this kind of warning ... gcc does have quite a few flags to suppress different kinds of warnings

Alternatively, you can reduce the warning level of the compilation process
What Kind of Coding Program is Right for You?

There are many ways to learn to code these days. From coding bootcamps like Flatiron School to online courses to totally free beginner resources. The best way to learn to code depends on many factors, but the most important one is you. See what course is best for you.

For the solaris compiler, use the option:

  CC -features=no%conststrings -c  myfile.C
avi_indiaAuthor Commented:
Can you please help me with gcc and Windows as well?

Warn whenever a pointer is cast so as to remove a type qualifier from the target type. For example, warn if a const char * is cast to an ordinary char *.
avi_indiaAuthor Commented:
only thing remains is now - Windows.. :)

Add a pragma to the source code

#pragma warning(disable:<warning number>)

Ofcourse for the same code to run on all platforms, you need to embed this in #ifdef ... something like this (I am not sure if __WINDOWS_32__ is the ifdef to use )

#ifdef __WINDOWS_32__
#pragma warning(disable:<warning number>)
For gcc:
-fwritable-strings -fno-const-strings


g++ -c -fwritable-strings -fno-const-strings  file.c

The -traditional flag does (or used to) do that too.. to treat pre-Standard C++
WIN32 is the macro to use.

#ifdef WIN32
"gcc -w" would supress all warnings. for specific warnings see the following extract.
this is from gcc man page:
     Warnings are diagnostic messages that  report  constructions
     which  are  not  inherently erroneous but which are risky or
     suggest there may have been an error.

     These options control the amount and kinds of warnings  pro-
     duced by GNU CC:

          Check the code for syntax errors, but  don't  emit  any

     -w   Inhibit all warning messages.

          Inhibit warning messages about the use of #import.

          Issue all the warnings demanded by strict ANSI standard
          C; reject all programs that use forbidden extensions.

          Valid ANSI standard C programs should compile  properly
          with or without this option (though a rare few will re-
          quire `-ansi').  However, without this option,  certain
          GNU extensions and traditional C features are supported
          as well.  With this option, they are  rejected.   There
          is  no  reason  to  use  this option; it exists only to
          satisfy pedants.

          `-pedantic' does not cause warning messages for use  of
          the  alternate  keywords whose names begin and end with
          `__'.  Pedantic warnings are also disabled in  the  ex-
          pression  that  follows  __extension__.   However, only
          system header files should use these escape routes; ap-
          plication programs should avoid them.

          Like `-pedantic', except that errors are produced rath-
          er than warnings.

     -W   Print extra warning messages for these events:

        o A nonvolatile automatic variable might be changed by  a
          call  to  longjmp.  These warnings are possible only in
          optimizing compilation.

          The compiler sees only the calls to setjmp.  It  cannot
          know  where  longjmp  will be called; in fact, a signal
          handler could call it at any point in the code.   As  a
          result,  you  may  get  a warning even when there is in
          fact no problem  because  longjmp  cannot  in  fact  be
          called at the place which would cause a problem.

        o A function can return either with or without  a  value.
          (Falling off the end of the function body is considered
          returning without a value.)  For example, this function
          would evoke such a warning:

          foo (a)
            if (a > 0)
              return a;

          Spurious warnings can occur because  GNU  CC  does  not
          realize  that  certain  functions  (including abort and
          longjmp) will never return.

        o An expression-statement or the left-hand side of a com-
          ma expression contains no side effects. To suppress the
          warning, cast the unused expression to void.  For exam-
          ple,  an expression such as `x[i,j]' will cause a warn-
          ing, but `x[(void)i,j]' will not.

        o An unsigned value is compared against zero with `>'  or

          Warn whenever a declaration does not specify a type.

          Warn whenever a function is used before being declared.

          Same   as   -Wimplicit-int   and   -Wimplicit-function-

          Warn if the main function is declared or defined with a
          suspicious  type.   Typically,  it  is  a function with
          external linkage, returning int, and taking zero or two

          Warn whenever a function is defined with a  return-type
          that  defaults  to  int.   Also  warn  about any return
          statement with no  return-value  in  a  function  whose
          return-type is not void.

          Warn whenever a local variable is unused aside from its
          declaration, whenever a function is declared static but
          never defined, and  whenever  a  statement  computes  a
          result that is explicitly not used.

          Warn whenever  a  switch  statement  has  an  index  of
          enumeral  type  and lacks a case for one or more of the
          named codes of that enumeration.  (The  presence  of  a
          default label prevents this warning.)  case labels out-
          side the enumeration range also provoke  warnings  when
          this option is used.

          Warn whenever a comment-start sequence `/*' appears  in
          a comment.

          Warn if any trigraphs are  encountered  (assuming  they
          are enabled).

          Check calls to printf and scanf,  etc.,  to  make  sure
          that  the  arguments supplied have types appropriate to
          the format string specified.

          Warn if an array subscript has type char.   This  is  a
          common cause of error, as programmers often forget that
          this type is signed on some machines.

          An automatic variable is used without first being  ini-

          These warnings are possible only in optimizing compila-
          tion,  because  they require data flow information that
          is computed only when optimizing.  If you don't specify
          `-O', you simply won't get these warnings.

          These warnings occur only for variables that are candi-
          dates  for register allocation.  Therefore, they do not
          occur for a variable  that  is  declared  volatile,  or
          whose  address is taken, or whose size is other than 1,
          2, 4 or 8 bytes.  Also, they do not  occur  for  struc-
          tures,  unions  or arrays, even when they are in regis-

          Note that there may be no warning about a variable that
          is  used  only  to compute a value that itself is never
          used, because such computations may be deleted by  data
          flow analysis before the warnings are printed.

          These warnings are made optional because GNU CC is  not
          smart  enough to see all the reasons why the code might
          be correct despite appearing to have an error.  Here is
          one example of how this can happen:

            int x;
            switch (y)
              case 1: x = 1;
              case 2: x = 4;
              case 3: x = 5;
            foo (x);
          If the value of y is always 1, 2 or 3, then x is always
          initialized,  but  GNU  CC  doesn't know this.  Here is
          another common case:

            int save_y;
            if (change_y) save_y = y, y = new_y;
            if (change_y) y = save_y;

          This has no bug because save_y is used only  if  it  is

          Some spurious warnings can be avoided if you declare as
          volatile all the functions you use that never return.

          Warn if parentheses are omitted in certain contexts.

          When using templates in a C++ program, warn  if  debug-
          ging is not yet fully available (C++ only).

          All of the above `-W' options combined.  These are  all
          the  options  which  pertain to usage that we recommend
          avoiding and that we believe is easy to avoid, even  in
          conjunction with macros.

     The remaining `-W...' options are not implied by `-Wall' be-
     cause they warn about constructions that we consider reason-
     able to use, on occasion, in clean programs.

          Warn about certain constructs that  behave  differently
          in traditional and ANSI C.

        o Macro arguments occurring within  string  constants  in
          the macro body.  These would substitute the argument in
          traditional C, but are part of the constant in ANSI C.

        o A function declared external in one block and then used
          after the end of the block.

        o A switch statement has an operand of type long.

          Warn whenever a local variable  shadows  another  local

          Warn whenever two distinct  identifiers  match  in  the
          first len characters.  This may help you prepare a pro-
          gram that will compile with  certain  obsolete,  brain-
          damaged compilers.

          Warn about anything that depends on  the  "size  of"  a
          function  type or of void.  GNU C assigns these types a
          size of 1, for convenience in calculations with void  *
          pointers and pointers to functions.

          Warn whenever a pointer is cast so as to remove a  type
          qualifier from the target type.  For example, warn if a
          const char * is cast to an ordinary char *.

          Warn whenever a pointer is cast such that the  required
          alignment  of  the  target  is increased.  For example,
          warn if a char * is cast to an int * on machines  where
          integers  can  only  be  accessed  at two- or four-byte

          Give string constants the type  const  char[length]  so
          that copying the address of one into a non-const char *
          pointer will get a warning.  These warnings  will  help
          you  find  at  compile  time code that can try to write
          into a string constant, but only if you have been  very
          careful  about  using  const in declarations and proto-
          types.  Otherwise, it will just be a nuisance; this  is
          why we did not make `-Wall' request these warnings.

          Warn if a prototype causes a type  conversion  that  is
          different  from  what would happen to the same argument
          in the absence of a prototype.  This  includes  conver-
          sions  of  fixed  point to floating and vice versa, and
          conversions changing the width or signedness of a fixed
          point argument except when the same as the default pro-

          Warn if any functions that return structures or  unions
          are defined or called.  (In languages where you can re-
          turn an array, this also elicits a warning.)

          Warn if a  function  is  declared  or  defined  without
          specifying  the argument types.  (An old-style function
          definition is permitted without a warning  if  preceded
          by a declaration which specifies the argument types.)

          Warn if a global function is defined without a previous
          prototype  declaration.  This warning is issued even if
          the definition itself provides a prototype.  The aim is
          to  detect global functions that fail to be declared in
          header files.

          Warn if a global function is defined without a previous
          declaration.   Do so even if the definition itself pro-
          vides a prototype.  Use this option  to  detect  global
          functions that are not declared in header files.

          Warn if anything is declared more than once in the same
          scope,  even  in  cases  where  multiple declaration is
          valid and changes nothing.

          Warn if an extern declaration is encountered within  an

          Warn about  conversion  between  different  enumeration
          types (C++ only).

          Warn if long long type is used.  This is  default.   To
          inhibit     the     warning    messages,    use    flag
          `-Wno-long-long'.      Flags     `-W-long-long'     and
          `-Wno-long-long'  are taken into account only when flag
          `-pedantic' is used.

          (C++ only.)  In a derived  class,  the  definitions  of
          virtual  functions  must  match the type signature of a
          virtual function declared in the base class.  Use  this
          option  to  request  warnings  when a derived class de-
          clares a function that may be an erroneous  attempt  to
          define  a  virtual function: that is, warn when a func-
          tion with the same name as a virtual  function  in  the
          base  class,  but  with  a  type signature that doesn't
          match any virtual functions from the base class.

          Warn if a function can not be inlined,  and  either  it
          was  declared as inline, or else the -finline-functions
          option was given.

          Treat warnings as errors; abort compilation  after  any

I couldn't find any command line option listing for treating strings like traditional C++. [no equivalent to gcc's -fwritable-strings -fno-const-strings]   It may be that there are options under environment config..

The caveat is that just shutting off warnings might not fix the actual problem that it's warning against.

If the compiler is doing string pooling and the program actually writes to the value of a string literal
somewhere, then the program might break.

And if other warnings go along with it (i.e. warnings about converting other const variables to non-const)
then seriously; it may be best to live with the warnings.

Since just ignoring other warnings of the same nature (that don't have to do with the string literals)
seems like a very risky approach
Hi jhshukla,

There is no point in copy pasting the manual atleast in this case. It only serves to increase the size of the page without adding any value. Please avoid cluttering the threads.

Question has a verified solution.

Are you are experiencing a similar issue? Get a personalized answer when you ask a related question.

Have a better answer? Share it in a comment.

Join & Write a Comment

Featured Post

What Kind of Coding Program is Right for You?

There are many ways to learn to code these days. From coding bootcamps like Flatiron School to online courses to totally free beginner resources. The best way to learn to code depends on many factors, but the most important one is you. See what course is best for you.

  • 5
  • 3
  • 3
  • +2
Tackle projects and never again get stuck behind a technical roadblock.
Join Now