Solved

String literal converted to char*

Posted on 2004-09-10
13
735 Views
Last Modified: 2012-06-27
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.

Regards
Ajay
0
Comment
Question by:avi_india
  • 5
  • 3
  • 3
  • +2
13 Comments
 
LVL 45

Expert Comment

by:sunnycoder
ID: 12033333
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)

Sunnycoder
0
 

Author Comment

by:avi_india
ID: 12033502
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.

0
 
LVL 45

Expert Comment

by:sunnycoder
ID: 12033506
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
0
 
LVL 23

Accepted Solution

by:
Mysidia earned 200 total points
ID: 12033558
For the solaris compiler, use the option:
  -features=no%conststrings

i.e.
  CC -features=no%conststrings -c  myfile.C
0
 

Author Comment

by:avi_india
ID: 12033597
Can you please help me with gcc and Windows as well?
0
 
LVL 45

Assisted Solution

by:sunnycoder
sunnycoder earned 200 total points
ID: 12033598
GCC:
http://gcc.gnu.org/onlinedocs/gcc-3.4.1/gcc/Option-Summary.html#Option%20Summary
http://gcc.gnu.org/onlinedocs/gcc-3.4.1/gcc/Warning-Options.html#Warning%20Options

-Wcast-qual
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 *.
0
Free Trending Threat Insights Every Day

Enhance your security with threat intelligence from the web. Get trending threat insights on hackers, exploits, and suspicious IP addresses delivered to your inbox with our free Cyber Daily.

 

Author Comment

by:avi_india
ID: 12033603
only thing remains is now - Windows.. :)

0
 
LVL 45

Expert Comment

by:sunnycoder
ID: 12033609
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>)
#endif
0
 
LVL 23

Expert Comment

by:Mysidia
ID: 12035239
For gcc:
-fwritable-strings -fno-const-strings

i.e.

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

The -traditional flag does (or used to) do that too.. to treat pre-Standard C++
0
 
LVL 7

Expert Comment

by:aib_42
ID: 12036344
WIN32 is the macro to use.

#ifdef WIN32
...
0
 
LVL 9

Expert Comment

by:jhshukla
ID: 12041373
"gcc -w" would supress all warnings. for specific warnings see the following extract.
this is from gcc man page:
=================
WARNING OPTIONS
     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:

     -fsyntax-only
          Check the code for syntax errors, but  don't  emit  any
          output.

     -w   Inhibit all warning messages.

     -Wno-import
          Inhibit warning messages about the use of #import.

     -pedantic
          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.

     -pedantic-errors
          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
          `<='.

     -Wimplicit-int
          Warn whenever a declaration does not specify a type.

     -Wimplicit-function-declaration
          Warn whenever a function is used before being declared.

     -Wimplicit
          Same   as   -Wimplicit-int   and   -Wimplicit-function-
          declaration.

     -Wmain
          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
          arguments.


     -Wreturn-type
          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.

     -Wunused
          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.

     -Wswitch
          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.

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

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

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

     -Wchar-subscripts
          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.

     -Wuninitialized
          An automatic variable is used without first being  ini-
          tialized.

          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-
          ters.

          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;
                break;
              case 2: x = 4;
                break;
              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
          set.

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

     -Wparentheses
          Warn if parentheses are omitted in certain contexts.

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

     -Wall
          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.

     -Wtraditional
          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.

     -Wshadow
          Warn whenever a local variable  shadows  another  local
          variable.

     -Wid-clash-len
          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.

     -Wpointer-arith
          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.

     -Wcast-qual
          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 *.

     -Wcast-align
          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
          boundaries.

     -Wwrite-strings
          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.

     -Wconversion
          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-
          motion.

     -Waggregate-return
          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.)

     -Wstrict-prototypes
          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.)

     -Wmissing-prototypes
          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.

     -Wmissing-declarations
          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.

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

     -Wnested-externs
          Warn if an extern declaration is encountered within  an
          function.

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

     -Wlong-long
          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.

     -Woverloaded-virtual
          (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.

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

     -Werror
          Treat warnings as errors; abort compilation  after  any
          warning.
0
 
LVL 23

Expert Comment

by:Mysidia
ID: 12041573
See
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclang/html/_predir_warning.asp

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
0
 
LVL 45

Expert Comment

by:sunnycoder
ID: 12041589
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.

sunnycoder
0

Featured Post

Better Security Awareness With Threat Intelligence

See how one of the leading financial services organizations uses Recorded Future as part of a holistic threat intelligence program to promote security awareness and proactively and efficiently identify threats.

Join & Write a Comment

Preface I don't like visual development tools that are supposed to write a program for me. Even if it is Xcode and I can use Interface Builder. Yes, it is a perfect tool and has helped me a lot, mainly, in the beginning, when my programs were small…
Summary: This tutorial covers some basics of pointer, pointer arithmetic and function pointer. What is a pointer: A pointer is a variable which holds an address. This address might be address of another variable/address of devices/address of fu…
The goal of this video is to provide viewers with basic examples to understand and use pointers in the C programming language.
The goal of this video is to provide viewers with basic examples to understand opening and reading files in the C programming language.

757 members asked questions and received personalized solutions in the past 7 days.

Join the community of 500,000 technology professionals and ask your questions.

Join & Ask a Question

Need Help in Real-Time?

Connect with top rated Experts

22 Experts available now in Live!

Get 1:1 Help Now