deprecated conversion from string constant to 'char*' [duplicate]

Answer 1

If you really want to modify Type:

char *Type = new char[10];
strcpy( Type, "Access" );

If you don't want to modify access:

const char *Type = "Access";

Please note, that, however, arrays of char in C and in C++ come with a lot of problems. For example, you don't really know if the call to new has been successful, or whether it is going to throw an exception. Also, strcpy() could surpass the limit of 10 chars.

So you can consider, if you want to modify type later:

std::string Type = "Access";

And if you don't want to modify it:

const std::string Type = "Access";

... the benefit of using std::string is that it is able to cope with all these issues.

Answer 2

There are a couple of things going on here.

char *Type = new char[10];

This create a char* pointer named Type and initializes it to point to the first element of a newly allocated 10-element array.

Type = "Access";  // ERROR

This assignment doesn't do what you think it does. It doesn't copy the 6-character string "Access" (7 characters including the terminating '\0') to the array you just created. Instead, it assigns a pointer to the first element of that array into your pointer Type. There are two problems with that.

First, it clobbers the previous value of Type. That 10-character array you just allocated now has nothing pointing to it; you can no longer access it or even deallocate it. This is a memory leak.

This isn't what the compiler is complaining about.

Second, a string literal creates a statically allocated const array ("statically allocated" meaning it exists for the entire execution of your program). Type is not declared with a const qualifier. If the compiler allowed you to point Type to the string "Access", you could use that pointer to (attempt to) modify it:

Type = "Access";
Type[0] = 'a'; // try to change the string to "access"

The purpose of const is to prevent you from modifying, or even attempting to modify, things that are read-only. That's why you're not allowed to assign a non-const pointer value to a const pointer object.

Since you're programming in C++, you're probably better off using std::string.

Answer 3

You've got a basic operations problem here, not a coding issue.

When you want to change the contents of a C char array, you do not use the assignment operator. That will instead change the value of the underlying pointer. Ick.

Instead you are supposed to use the C string library routines. For instance, strcpy (Type, "Access"); will copy the string literal "Access" into your character array, with its all-important trailing nul character.

If you are using C++ (as your tags indicate), you should probably be using std::string instead of arrays of char. Assignment works they way you are expecting there.

Answer 4

I want to pass a string via char* to a function.

Here is how you can pass a string via char* to a function (note the required const keyword in the function signature.)

#include <iostream>
void f(const char* p) {
  std::cout << p << "\n";
}

int main() {
  f("Access");
}

But, what if you are invoking an existing function, and cannot modify its signature?

If you have some external guarantee that the function will not write through its argument pointer,

#include <iostream>
void f(char* p) {
  std::cout << p << "\n";
}

int main() {
  f(const_cast<char*>("Access"));
}

If, on the other hand, the function might write to the string, then you'll need to allocate space for the string:

#include <iostream>
void f(char* p) {
  *++p;
  std::cout << p << "\n";
}

int main() {
  // Allocate read-write space on the heap
  char *p = new char[strlen("Access"+1)];
  // Copy string to allocated space
  strcpy(p, "Access");
  f(p);
  delete p;
}

or,

#include <iostream>
void f(char* p) {
  *++p;
  std::cout << p << "\n";
}

int main() {
  // Allocate read-write space on the stack
  char arr[] = "Access";
  f(arr);
}

But, the best course by far is to avoid the whole pointer mishegas:

#include <iostream>
void f(const std::string& p) {
  std::cout << p << "\n";
}

int main() {
  f("Access");
}