有一个类A，类A中有一个成员函数，用类A创建一个指针并指向NULL，这个指针能否访问类A中的成员函数

不，一个指向 NULL 的指针无法访问类 A 中的成员函数。当一个指针被赋值为 NULL，它表示指向空内存地址，即没有指向任何对象或数据。因此，尝试通过 NULL 指针访问类 A 的成员函数将导致错误。

要访问类 A 中的成员函数，必须使用有效的对象或指向有效对象的指针。只有当指针指向一个实例化的对象时，才能通过指针访问该对象的成员函数。如果你想通过指针访问类 A 的成员函数，你需要确保该指针指向一个有效的类 A 对象，而不是 NULL。

相关问题

a.b 是一个结构体指针数组，a.b[i]！=NULL

如果 `a.b` 是一个结构体指针数组，那么 `a.b[i]` 表示指向第 `i` 个元素的指针。因此，`a.b[i] != NULL` 表示判断第 `i` 个元素的指针是否为 NULL。

如果 `a.b[i] != NULL` 成立，就表示第 `i` 个元素的指针指向了一个有效的内存地址，可以通过该指针访问到对应的结构体实例。这时，就可以使用箭头符号 `->` 访问结构体中的成员。例如：

struct Example {
  int value;
  char name[20];
};

struct Example *a[10];

// 判断第 i 个元素是否为 NULL
if (a[i] != NULL) {
  // 访问结构体中的成员
  printf("value: %d, name: %s\n", a[i]->value, a[i]->name);
}

这里定义了一个 `struct Example` 结构体，并声明了一个结构体指针数组 `a`。在使用 `a` 之前，需要先为其分配内存空间，并初始化数组中的每个元素为 NULL。然后可以使用 `a[i] != NULL` 来判断第 `i` 个元素是否为 NULL。如果不为 NULL，就可以使用箭头符号 `->` 访问结构体中的成员。

需要注意的是，在使用完 `a` 后，需要使用 `free` 函数释放其占用的内存空间。例如：

// 释放内存空间
for (int i = 0; i < 10; i++) {
  if (a[i] != NULL) {
    free(a[i]);
  }
}

共享内存 传一个类指针_C语言指针最详尽的讲解

在C语言中，指针是一种非常重要的数据类型，它可以指向其他数据类型的地址，使得程序可以直接访问这些数据。共享内存是一种进程之间共享数据的方式，可以让多个进程同时访问同一个内存区域。下面详细介绍如何在C语言中使用指针来传递类指针和共享内存。

首先，我们需要了解如何使用指针来传递类指针。在C++中，类指针是一种指向类对象的指针，它可以访问类的成员函数和成员变量。在C语言中，我们可以使用void指针来传递类指针。具体实现方法如下：

// 定义一个类
class MyClass {
public:
    void func() { // 成员函数 }
    int value; // 成员变量
};

// 在C语言中使用void指针来传递类指针
void myFunc(void* ptr) {
    MyClass* myClassPtr = (MyClass*)ptr; // 将void指针转换为MyClass指针
    myClassPtr->func(); // 调用类的成员函数
    myClassPtr->value = 10; // 访问类的成员变量
}

在上述代码中，我们首先定义了一个类MyClass，并在C语言函数myFunc中使用void指针来传递类指针。在函数内部，我们将void指针转换为MyClass指针，然后就可以使用类的成员函数和成员变量了。

接下来，我们来介绍如何在共享内存中传递类指针。在Linux系统中，我们可以使用shmget、shmat等函数来创建和操作共享内存。具体实现方法如下：

#include <sys/ipc.h>
#include <sys/shm.h>

// 定义一个类
class MyClass {
public:
    void func() { // 成员函数 }
    int value; // 成员变量
};

// 创建共享内存
int createSharedMemory() {
    int shmid = shmget(IPC_PRIVATE, sizeof(MyClass), 0666|IPC_CREAT);
    if (shmid == -1) {
        perror("shmget error");
        exit(EXIT_FAILURE);
    }
    return shmid;
}

// 将类指针附加到共享内存
MyClass* attachToSharedMemory(int shmid) {
    void* sharedMemory = shmat(shmid, NULL, 0);
    if (sharedMemory == (void*)-1) {
        perror("shmat error");
        exit(EXIT_FAILURE);
    }
    return (MyClass*)sharedMemory;
}

// 分离共享内存
void detachFromSharedMemory(MyClass* myClassPtr) {
    if (shmdt(myClassPtr) == -1) {
        perror("shmdt error");
        exit(EXIT_FAILURE);
    }
}

// 销毁共享内存
void destroySharedMemory(int shmid) {
    if (shmctl(shmid, IPC_RMID, NULL) == -1) {
        perror("shmctl error");
        exit(EXIT_FAILURE);
    }
}

// 在共享内存中传递类指针
void myFunc(MyClass* myClassPtr) {
    // 共享内存中的类指针与传入的类指针指向同一个对象
    myClassPtr->func(); // 调用类的成员函数
    myClassPtr->value = 10; // 访问类的成员变量
}

int main() {
    // 创建共享内存
    int shmid = createSharedMemory();
    // 将类指针附加到共享内存
    MyClass* myClassPtr = attachToSharedMemory(shmid);

    // 在不同的进程中调用myFunc函数，共享内存中的类指针会被传递到另一个进程中
    myFunc(myClassPtr);

    // 分离共享内存
    detachFromSharedMemory(myClassPtr);
    // 销毁共享内存
    destroySharedMemory(shmid);

    return 0;
}

在上述代码中，我们首先定义了一个类MyClass，并使用shmget、shmat等函数来创建和操作共享内存。在函数myFunc中，我们可以直接使用共享内存中的类指针来调用类的成员函数和成员变量。在不同的进程中调用myFunc函数，共享内存中的类指针会被传递到另一个进程中。

总之，在C语言中，我们可以使用指针来传递类指针和操作共享内存，这种方式可以让多个进程同时访问同一个内存区域，从而实现数据共享的功能。