如何分配字符串文字

Question

我是一名Java程序员；我最后一次编写 C 或 C++ 是在 20 年前。现在我回来了，我正在尝试使用更现代的 C++，例如 C++11/C++14，并避免旧的 C 风格编程。

如何分配字符串，如 Java 中：

private static final String MY_STRING = "Hello World"; // could also be public

现在我有了对文本

MY_STRING

的引用

"Hello World"

，我可以在程序中根据需要多次使用它，如果我想将其更改为

"Hello Dolly"

，我只需一次即可完成更改单一地点。

我想在 C++ 中实现同样的目标。 示例：

JavaVMOption* options = new JavaVMOption[1];

options[0].optionString = (char *)"-Djava.class.path=.";

这可行，没有更多问题，但我不喜欢它，因为要求只能在需要时才能在一处更改它。 所以，我声明（即使在头文件中）：

std::string classpath = "-Djava.class.path=.";
// or
const std::string classpath = "-Djava.class.path=.";

我用它作为：

options[0].optionString = (char *)classpath.c_str();

现在，使用

c_str()

函数，这也有效，但我又回到了普通的旧 C！

我真的很想知道是否有办法保持更现代的 C++ 水平？

是的，我知道，

JavaVMOption* options = new JavaVMOption[1]; 

已按原样声明，我无法更改它。但即使在 C++ 中，在给定情况下使用引用而不是像 Java 中那样使用指针也是一个好主意。有解决办法吗？我没找到。

Answer 1

"Hello"

是一个包含 6 个

char

的常量缓冲区，其值分别为

H

e

l

l

o

\0

，其生命周期为整个程序。

std::string bob = "Hello";

将该缓冲区复制到

std::string

对象中。

std::string

是一个值语义对象；这是 Java 往往缺乏的东西，因为所有对象都是通过引用隐式传递的。

options[0].optionString = (char *)"-Djava.class.path=.";

这是极其危险的。您将该缓冲区转换为指向

const

的非

char

指针，然后将其分配给

optionString

。

我不知道

optionString

是什么，但如果它是

char*

类型的变量，这会让你面临未定义的行为。对缓冲区

"-Djava.class.path=."

的任何编辑都是未定义的行为，并且存储指向此类缓冲区的非

const

指针只是乞求这种情况发生。

简而言之，

optionString

的类型是其危险程度的关键。这只是鲁莽，还是真的很愚蠢？

JavaVMOption* options = new JavaVMOption[1];

这会在堆上创建一个大小为

JavaVMOption

的

1

数组，然后存储指向

options

中第一个元素的指针。

这里有很多无意义的事情。销毁它需要将其作为数组销毁？

JavaVMOption options;

这会在堆栈上创建一个名为

JavaVMOption

的

options

。它会在作用域结束时自动销毁。这看起来实用得多。除非您需要

new

，否则使用

new

是没有意义的，并且在 C++ 中很少需要

new

。

我找到了一些示例代码：

#include <jni.h>       /* where everything is defined */
...
JavaVM *jvm;       /* denotes a Java VM */
JNIEnv *env;       /* pointer to native method interface */
JavaVMInitArgs vm_args; /* JDK/JRE 6 VM initialization arguments */
JavaVMOption* options = new JavaVMOption[1];
options[0].optionString = "-Djava.class.path=/usr/lib/java";
vm_args.version = JNI_VERSION_1_6;
vm_args.nOptions = 1;
vm_args.options = options;
vm_args.ignoreUnrecognized = false;
/* load and initialize a Java VM, return a JNI interface
 * pointer in env */
JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args);
delete options;
/* invoke the Main.test method using the JNI */
jclass cls = env->FindClass("Main");
jmethodID mid = env->GetStaticMethodID(cls, "test", "(I)V");
env->CallStaticVoidMethod(cls, mid, 100);
/* We are done. */
jvm->DestroyJavaVM();

那不是由以 C++ 编程为生的人写的。

这是我的初步尝试：

struct destroy_java_vm {
  void operator()(JavaVM* jvm)const{
    jvm->DestroyJavaVM();
  }
};
using up_java_vm = std::unique_ptr< JavaVM, destroy_java_vm >;

struct java_vm {
  up_java_vm vm;
  JNIEnv* env = 0;
};
struct java_vm_option {
  std::string string;
  std::shared_ptr<void> extra_info;
};
using java_vm_options = std::vector<java_vm_option>;

struct java_vm_init {
  unsigned version = JNI_VERSION_1_2;
  java_vm_options options;
  bool ignore_unrecognized = false;
  java_vm init() {
    std::vector<JavaVMOption> java_options(options.size());
    for (std::size_t i = 0; i < options.size(); ++i) {
      java_options[i].optionString = &options.string[0];
      java_options[i].extraInfo = options.extra_info.get();
    }
    JavaVMInitArgs args;
    args.version = version;
    args.options = java_options.data();
    args.nOptions = java_options.size();
    args.ignoreUnrecognized = ignore_unrecognized?TRUE:FALSE;
    java_vm retval;
    JavaVM* tmp = 0;
    auto res = JNI_CreateJavaVM(&tmp, (void **)&retval.env, &args);
    if (res < 0) {
      return {}; // error message?  How?
    }
    retval.vm.reset( tmp );
    return retval;
  }
}

用途：

java_vm_init init;
init.options.push_back("-Djava.class.path=.");
auto vm = init.init();
if (!vm.env) { return /* error case */; }
/* invoke the Main.test method using the JNI */
jclass cls = vm.env->FindClass("Main");
jmethodID mid = vm.env->GetStaticMethodID(cls, "test", "(I)V");
vm.env->CallStaticVoidMethod(cls, mid, 100);
/* We are done. */

通过我对

unique_ptr

的使用，

java_vm

对象是一种只能移动的值类型。当它被销毁时，java vm会自动销毁（如果你没有将其移出）。

直接与 API 对话时，我们必须转向 C 风格代码，因为许多跨语言 API 都是使用 C 风格接口编写的。我们将 C 风格的接口封装在更安全、更易于使用的 C++ 类型中。

代码未经测试，可能包含拼写错误。

Answer 2

我是一名java程序员，当我尝试使用JNI从C++调用Java时，我发现了同样的例子。也就是说，我不知道这是否“正确”，但它通过更改原始代码使代码编译没有错误：

JavaVMOption* options = new JavaVMOption[1];   // JVM invocation options
options[0].optionString = "-Djava.class.path=."

使用 char 数组代替。

JavaVMOption* options = new JavaVMOption[1];
char classpath[] = "-Djava.class.path=.";
options[0].optionString = classpath;

我的基本理解是 char* 与 char[] 相同。