函数形参类型为const char*或void *会涉及内存拷贝吗

函数形参类型为const char*或void*，在函数调用时不会发生内存拷贝。这是因为这两种类型的形参本质上是指针，它们只是指向内存地址的指针，并不涉及对实际数据的拷贝。

当使用const char*作为函数形参类型时，它通常用于传递字符串的指针。在函数调用时，只需传递字符串的地址给形参即可，不会发生字符串本身的拷贝。

而void*是一个通用的指针类型，可以指向任何类型的数据。在函数调用时，可以传递任意类型的指针给形参，同样不会发生实际数据的拷贝。

需要注意的是，虽然函数调用时不会发生内存拷贝，但在函数内部对指针所指向的数据进行修改时，会影响到原始数据。因此，在使用这两种类型作为函数形参时，需要注意对指针所指向数据的访问和修改操作。

相关问题

void * 类型转换为const char * 类型会有内存拷贝吗

将`void*`类型转换为`const char*`类型不会发生内存拷贝。这是因为`void*`是一个通用的指针类型，可以指向任何类型的数据，包括`char`类型的数据。

在C或C++中，将`void*`指针转换为其他类型的指针时，只是告诉编译器如何解释这段内存的内容，并不会实际进行内存拷贝操作。

当你将`void*`类型指针转换为`const char*`类型指针时，编译器会根据你的指令将这段内存解释为一串字符（C字符串）。这个过程只是给予了编译器一个解释内存内容的方式，没有实际拷贝数据的动作。

需要注意的是，在进行这种类型转换时，你需要确保原始的`void*`指针指向的内存确实包含了有效的C字符串，否则可能会导致未定义行为。

定义一个字符串类 String 数据成员（访问权限定义为protected）： 指向存放字符串内容的字符指针（char *str） 成员函数（访问权限定义为public）： 默认构造函数：初始化成一个空串 String( ); 带参数的构造函数：根据参数内容初始化字符串 String(const char *content); 拷贝构造函数：初始化字符串 String(const String &cstr); 析构函数：释放堆空间 ~String( ); 设置字符串内容 void set(const char *content); 获取字符串长度（定义为const成员函数）int length() const; 打印字符串内容（定义为const成员函数）void print() const; 重载赋值运算符= （只能作为类成员函数重载） String& operator=(const String &cstr); String& operator=(const char *cstr); 重载下标运算符[ ]，实现获取字符串中某个指定位置的字符 （只能作为类成员函数重载） char& operator[](int index); 重载类型转换运算符 char *，实现将字符串类强制转换成字符指针（只能作为类成员函数重载） operator char*( ); 要求：将类的定义与类成员函数的实现分开。

类定义如下：

class String {
protected:
    char* str;  // 存储字符串内容的字符指针
public:
    String();  // 默认构造函数
    String(const char* content);  // 带参数的构造函数
    String(const String& cstr);  // 拷贝构造函数
    ~String();  // 析构函数
    void set(const char* content);  // 设置字符串内容
    int length() const;  // 获取字符串长度
    void print() const;  // 打印字符串内容
    String& operator=(const String& cstr);  // 重载赋值运算符=
    String& operator=(const char* cstr);  // 重载赋值运算符=
    char& operator[](int index);  // 重载下标运算符[]
    operator char*();  // 重载类型转换运算符
};

类成员函数的实现如下：

// 默认构造函数
String::String() {
    str = new char[1];
    str[0] = '\0';
}

// 带参数的构造函数
String::String(const char* content) {
    int len = strlen(content);
    str = new char[len + 1];
    strcpy(str, content);
}

// 拷贝构造函数
String::String(const String& cstr) {
    int len = strlen(cstr.str);
    str = new char[len + 1];
    strcpy(str, cstr.str);
}

// 析构函数
String::~String() {
    delete[] str;
}

// 设置字符串内容
void String::set(const char* content) {
    delete[] str;
    int len = strlen(content);
    str = new char[len + 1];
    strcpy(str, content);
}

// 获取字符串长度
int String::length() const {
    return strlen(str);
}

// 打印字符串内容
void String::print() const {
    printf("%s", str);
}

// 重载赋值运算符=
String& String::operator=(const String& cstr) {
    if (this == &cstr) return *this;  // 自我赋值
    delete[] str;
    int len = strlen(cstr.str);
    str = new char[len + 1];
    strcpy(str, cstr.str);
    return *this;
}

String& String::operator=(const char* cstr) {
    delete[] str;
    int len = strlen(cstr);
    str = new char[len + 1];
    strcpy(str, cstr);
    return *this;
}

// 重载下标运算符[]
char& String::operator[](int index) {
    return str[index];
}

// 重载类型转换运算符
String::operator char*() {
    return str;
}