Android学习19 -- NDK4--共享内存（TODO）

server/2025/1/1 10:10:23/

在安卓的NDK（Native Development Kit）中，C++共享内存通常用于不同进程间的通信，或者在同一进程中多线程之间共享数据。这种方法相较于其他形式的IPC（进程间通信）来说，具有更高的性能和低延迟。共享内存提供了一块可以被多个进程访问的内存区域，但它的使用需要小心，以避免并发问题和内存访问冲突。

以下是如何在安卓NDK下使用C++进行共享内存的一些基本概念和实现方法：

1. 使用 ashmem（Android共享内存）

Android提供了ashmem（Android Shared Memory）用于跨进程共享内存。它是安卓平台上特定于共享内存的一种机制，可以通过文件描述符来实现共享内存区域。

基本步骤：

  1. 创建共享内存： 使用ashmem_create_region()函数创建共享内存区域。

    #include <sys/mman.h>
#include <unistd.h>
#include <fcntl.h>
#include <ashmem.h>int create_shared_memory(size_t size) {int fd = ashmem_create_region("my_shared_memory", size);if (fd < 0) {perror("Failed to create shared memory");return -1;}return fd;
}

  2. 映射共享内存： 使用mmap函数将共享内存映射到进程的虚拟地址空间。

    void* map_shared_memory(int fd, size_t size) {void* addr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);if (addr == MAP_FAILED) {perror("Failed to map shared memory");return nullptr;}return addr;
}

  3. 写入/读取共享内存： 映射后，可以直接通过指针访问共享内存。

    void write_to_shared_memory(void* addr, const char* data) {memcpy(addr, data, strlen(data) + 1);
}void read_from_shared_memory(void* addr) {printf("Data from shared memory: %s\n", (char*)addr);
}

  4. 关闭共享内存： 使用munmap和close来卸载和关闭共享内存。

    void unmap_shared_memory(void* addr, size_t size) {munmap(addr, size);
}void close_shared_memory(int fd) {close(fd);
}

2. 使用 mmap 和普通文件

如果需要跨进程共享内存，可以使用mmap映射一个物理文件作为共享内存。文件在磁盘上存在，但多个进程可以通过映射来共享这个文件的内存区域。

#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>int create_shared_memory_file(const char* path, size_t size) {int fd = open(path, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);if (fd == -1) {perror("Failed to open file");return -1;}if (ftruncate(fd, size) == -1) {perror("Failed to set file size");close(fd);return -1;}return fd;
}void* map_shared_memory_file(int fd, size_t size) {void* addr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);if (addr == MAP_FAILED) {perror("Failed to map shared memory");return nullptr;}return addr;
}void unmap_shared_memory(void* addr, size_t size) {munmap(addr, size);
}

3. 线程间共享内存

在同一进程中的多个线程也可以通过共享内存来交换数据。共享内存在多线程场景下的使用是非常常见的，因为它允许线程直接访问共享数据，而无需进行复杂的序列化。

#include <pthread.h>
#include <atomic>std::atomic<int> shared_counter(0);void* thread_func(void* arg) {shared_counter.fetch_add(1, std::memory_order_relaxed);return nullptr;
}int main() {pthread_t threads[10];for (int i = 0; i < 10; ++i) {pthread_create(&threads[i], nullptr, thread_func, nullptr);}for (int i = 0; i < 10; ++i) {pthread_join(threads[i], nullptr);}printf("Shared counter: %d\n", shared_counter.load());return 0;
}

4. 注意事项

  • 同步问题：共享内存的访问需要确保线程或进程间的同步。可以使用mutex、semaphore或其他同步机制来防止竞态条件。

  • 资源管理：共享内存资源需要适当管理，避免内存泄漏。确保共享内存被正确地映射、使用和释放。

  • 权限控制：对于跨进程的共享内存，必须确保各个进程具有访问该内存区域的权限，否则可能会导致访问错误。

总结

安卓NDK中使用C++进行共享内存操作主要通过ashmem或mmap来实现。ashmem是专为Android设计的共享内存机制，适用于跨进程通信；而mmap可以用于映射普通文件作为共享内存。共享内存在多进程和多线程之间的数据交换中非常有用，但需要注意同步和资源管理的问题。

在安卓NDK下，多个进程共享一个共享内存的例子通常可以通过ashmem（Android共享内存）来实现。ashmem允许不同的进程通过文件描述符访问同一块内存区域，从而实现跨进程的共享内存通信。

下面是一个简单的例子，展示了如何使用ashmem在两个进程间共享内存。进程A写入共享内存，进程B读取共享内存。

步骤概述：

  1. 进程A：创建共享内存并将数据写入内存。
  2. 进程B：访问同一共享内存并读取数据。

1. 进程A：创建共享内存并写入数据

进程A代码 (process_a.cpp)
#include <stdio.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <ashmem.h>int create_shared_memory(size_t size) {int fd = ashmem_create_region("my_shared_memory", size);if (fd < 0) {perror("Failed to create shared memory");return -1;}return fd;
}void* map_shared_memory(int fd, size_t size) {void* addr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);if (addr == MAP_FAILED) {perror("Failed to map shared memory");return nullptr;}return addr;
}int main() {const size_t size = 1024;  // 定义共享内存大小const char* message = "Hello from Process A!";// 创建共享内存int fd = create_shared_memory(size);if (fd < 0) {return 1;}// 映射共享内存void* addr = map_shared_memory(fd, size);if (addr == nullptr) {close(fd);return 1;}// 将数据写入共享内存strncpy((char*)addr, message, size);printf("Process A: Written to shared memory: %s\n", message);// 关闭共享内存munmap(addr, size);close(fd);return 0;
}

2. 进程B：访问共享内存并读取数据

进程B代码 (process_b.cpp)
#include <stdio.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <ashmem.h>void* map_shared_memory(int fd, size_t size) {void* addr = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);if (addr == MAP_FAILED) {perror("Failed to map shared memory");return nullptr;}return addr;
}int main() {const size_t size = 1024;  // 定义共享内存大小// 打开已有的共享内存文件描述符int fd = open("/dev/ashmem/my_shared_memory", O_RDONLY);if (fd < 0) {perror("Failed to open shared memory");return 1;}// 映射共享内存void* addr = map_shared_memory(fd, size);if (addr == nullptr) {close(fd);return 1;}// 读取共享内存中的数据printf("Process B: Read from shared memory: %s\n", (char*)addr);// 关闭共享内存munmap(addr, size);close(fd);return 0;
}

3. 编译和运行

  1. 编译代码： 你需要将process_a.cpp和process_b.cpp分别编译成独立的可执行文件。

    在终端中使用NDK编译工具（如ndk-build或CMake）编译代码。确保设置正确的NDK环境。

    例如，使用CMake时，创建一个CMakeLists.txt文件来设置编译参数：

    cmake_minimum_required(VERSION 3.4.1)add_executable(process_a process_a.cpp)
add_executable(process_b process_b.cpp)

    使用CMake进行构建：

    mkdir build
cd build
cmake ..
make

  2. 运行进程A： 启动进程A，它会创建共享内存并写入数据。

    ./process_a

  3. 运行进程B： 启动进程B，它会读取进程A写入共享内存中的数据。

    ./process_b

4. 说明

  • 创建共享内存：进程A通过调用ashmem_create_region()函数来创建共享内存。这个函数返回一个文件描述符，可以通过该文件描述符在其他进程中访问共享内存。

  • 映射共享内存：进程A和进程B通过mmap()函数将共享内存映射到各自的地址空间，读取或写入共享内存的数据。

  • 数据传输：进程A将数据写入共享内存，进程B从共享内存读取数据。这两者通过共享内存实现了数据传输。

  • 进程间共享内存访问：共享内存的访问方式是基于文件描述符的，通过文件描述符，可以在不同的进程之间共享这块内存。ashmem是一种轻量级的共享内存方式，适用于安卓中的跨进程数据共享。

5. 注意事项

  • 由于共享内存没有内建的同步机制，多个进程同时访问时需要通过锁（例如mutex、semaphore）来保证数据一致性。
  • 在实际开发中，可能还需要设置共享内存的权限（如只读或读写），以保证数据的安全性。

通过这个例子，你可以看到如何在安卓NDK中使用C++进行共享内存的创建和访问，实现多个进程间的数据共享。

在安卓NDK下，使用共享内存实现生产者消费者模型，涉及多个进程通过共享内存进行数据交换。一个进程作为生产者写入数据，多个消费者进程从共享内存中读取数据。

关键概念：

  1. 共享内存：生产者和消费者进程使用共享内存区域进行数据交换。ashmem是一个适用于安卓的共享内存机制。
  2. 同步机制：由于多个进程访问共享内存，必须确保数据一致性和避免竞争条件。因此，使用同步机制（如信号量）来控制数据的读写。

示例描述：

  • 生产者进程：产生数据并写入共享内存。
  • 消费者进程：从共享内存中读取数据并消费。

为了实现这一模型，我们将使用ashmem来创建共享内存区域，并使用简单的信号量（例如通过sem_t）来同步进程之间的读写。

1. 数据结构和共享内存设计

首先定义一个简单的共享内存结构，其中包括一个缓冲区、读写指针和信号量，用于同步。

// shared_memory.h
#ifndef SHARED_MEMORY_H
#define SHARED_MEMORY_H#include <semaphore.h>#define BUFFER_SIZE 10  // 缓冲区大小// 共享内存结构
struct shared_memory {int buffer[BUFFER_SIZE];   // 数据缓冲区int read_index;            // 读取位置int write_index;           // 写入位置sem_t full;                // 缓冲区中的数据数量sem_t empty;               // 缓冲区中的空位数量sem_t mutex;               // 互斥锁，保护缓冲区的读写
};#endif

2. 生产者进程（写入共享内存）

生产者进程不断生成数据，并将数据写入共享内存。在每次写入后，生产者会通知消费者进程。

生产者代码 (producer.cpp)
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <semaphore.h>
#include <string.h>
#include "shared_memory.h"
#include <ashmem.h>int main() {// 打开共享内存int fd = open("/dev/ashmem/my_shared_memory", O_RDWR);if (fd == -1) {perror("Failed to open shared memory");return -1;}// 映射共享内存struct shared_memory *shm = (struct shared_memory *)mmap(NULL, sizeof(struct shared_memory),PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);if (shm == MAP_FAILED) {perror("Failed to map shared memory");close(fd);return -1;}// 写入数据的生产者循环for (int i = 0; i < 100; ++i) {// 等待空槽位sem_wait(&shm->empty);sem_wait(&shm->mutex);// 生成数据并写入缓冲区shm->buffer[shm->write_index] = i;printf("Producer: produced %d\n", i);// 更新写入位置shm->write_index = (shm->write_index + 1) % BUFFER_SIZE;// 释放互斥锁，通知消费者sem_post(&shm->mutex);sem_post(&shm->full);// 模拟生产者的工作时间sleep(1);}// 解除共享内存映射munmap(shm, sizeof(struct shared_memory));close(fd);return 0;
}

3. 消费者进程（读取共享内存）

消费者进程从共享内存中读取数据，并进行消费。在每次读取后，消费者会通知生产者进程。

消费者代码 (consumer.cpp)
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <semaphore.h>
#include <string.h>
#include "shared_memory.h"
#include <ashmem.h>int main() {// 打开共享内存int fd = open("/dev/ashmem/my_shared_memory", O_RDWR);if (fd == -1) {perror("Failed to open shared memory");return -1;}// 映射共享内存struct shared_memory *shm = (struct shared_memory *)mmap(NULL, sizeof(struct shared_memory),PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);if (shm == MAP_FAILED) {perror("Failed to map shared memory");close(fd);return -1;}// 消费者循环for (int i = 0; i < 100; ++i) {// 等待缓冲区中有数据sem_wait(&shm->full);sem_wait(&shm->mutex);// 从缓冲区读取数据int item = shm->buffer[shm->read_index];printf("Consumer: consumed %d\n", item);// 更新读取位置shm->read_index = (shm->read_index + 1) % BUFFER_SIZE;// 释放互斥锁，通知生产者sem_post(&shm->mutex);sem_post(&shm->empty);// 模拟消费者的工作时间sleep(1);}// 解除共享内存映射munmap(shm, sizeof(struct shared_memory));close(fd);return 0;
}

4. 创建和初始化共享内存

共享内存需要在生产者和消费者进程启动前创建，并初始化必要的信号量。这里我们需要一个初始化共享内存的代码。

初始化共享内存 (init_shared_memory.cpp)
#include <stdio.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
#include <semaphore.h>
#include <string.h>
#include <ashmem.h>
#include "shared_memory.h"int main() {// 创建共享内存int fd = open("/dev/ashmem/my_shared_memory", O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);if (fd == -1) {perror("Failed to create shared memory");return -1;}// 设置共享内存大小if (ftruncate(fd, sizeof(struct shared_memory)) == -1) {perror("Failed to set memory size");close(fd);return -1;}// 映射共享内存struct shared_memory *shm = (struct shared_memory *)mmap(NULL, sizeof(struct shared_memory),PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);if (shm == MAP_FAILED) {perror("Failed to map shared memory");close(fd);return -1;}// 初始化缓冲区shm->read_index = 0;shm->write_index = 0;// 初始化信号量sem_init(&shm->full, 1, 0);       // full: initially 0sem_init(&shm->empty, 1, BUFFER_SIZE);  // empty: initially BUFFER_SIZEsem_init(&shm->mutex, 1, 1);      // mutex: initially unlocked (1)// 解除共享内存映射munmap(shm, sizeof(struct shared_memory));close(fd);printf("Shared memory initialized.\n");return 0;
}

5. 编译和运行

首先编译这三个程序：init_shared_memory.cpp、producer.cpp 和 consumer.cpp。

g++ init_shared_memory.cpp -o init_shared_memory -lstdc++ -lpthread
g++ producer.cpp -o producer -lstdc++ -lpthread
g++ consumer.cpp -o consumer -lstdc++ -lpthread

然后，按照以下顺序执行：

  1. 初始化共享内存： 在任何生产者或消费者进程运行之前，先运行初始化共享内存的程序。

    ./init_shared_memory

  2. 启动生产者进程： 启动生产者进程，它会开始生成数据并写入共享内存。

    ./producer

  3. 启动消费者进程： 启动多个消费者进程，读取共享内存中的数据。

    ./consumer

    可以启动多个消费者进程，如：

    ./consumer &
./consumer &

总结

在这个例子中，我们通过共享内存和信号量实现了生产者-消费者模式。生产者通过共享内存写入数据，多个消费者读取并消费数据。信号量确保了在多进程环境中对共享内存的同步访问。

在安卓 NDK 中使用 C++ 和共享内存实现生产者消费者模型，且采用 条件变量 进行同步，需要确保生产者和消费者在共享内存的读写操作中正确同步。

关键步骤：

  1. 共享内存：使用 ashmem 共享内存来传递数据。
  2. 互斥锁和条件变量：使用 pthread_mutex_t 和 pthread_cond_t 来实现生产者和消费者的同步。

示例设计：

  • 生产者进程：生成数据并写入共享内存。
  • 消费者进程：从共享内存中读取数据并进行消费。
  • 通过条件变量来保证数据写入和读取的同步：
    • 生产者在缓冲区满时等待。
    • 消费者在缓冲区空时等待。

1. 数据结构和共享内存设计

// shared_memory.h
#ifndef SHARED_MEMORY_H
#define SHARED_MEMORY_H#include <pthread.h>#define BUFFER_SIZE 10  // 缓冲区大小// 共享内存结构
struct shared_memory {int buffer[BUFFER_SIZE];   // 数据缓冲区int read_index;            // 读取位置int write_index;           // 写入位置pthread_mutex_t mutex;     // 互斥锁，保护缓冲区的读写pthread_cond_t full_cond;  // 条件变量，缓冲区满时等待pthread_cond_t empty_cond; // 条件变量，缓冲区空时等待
};#endif

2. 初始化共享内存

初始化共享内存区域，包括互斥锁和条件变量。

初始化共享内存 (init_shared_memory.cpp)
#include <stdio.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
#include <ashmem.h>
#include "shared_memory.h"int main() {// 创建共享内存int fd = open("/dev/ashmem/my_shared_memory", O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);if (fd == -1) {perror("Failed to create shared memory");return -1;}// 设置共享内存大小if (ftruncate(fd, sizeof(struct shared_memory)) == -1) {perror("Failed to set memory size");close(fd);return -1;}// 映射共享内存struct shared_memory *shm = (struct shared_memory *)mmap(NULL, sizeof(struct shared_memory),PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);if (shm == MAP_FAILED) {perror("Failed to map shared memory");close(fd);return -1;}// 初始化缓冲区shm->read_index = 0;shm->write_index = 0;// 初始化互斥锁和条件变量pthread_mutex_init(&shm->mutex, NULL);pthread_cond_init(&shm->full_cond, NULL);pthread_cond_init(&shm->empty_cond, NULL);// 解除共享内存映射munmap(shm, sizeof(struct shared_memory));close(fd);printf("Shared memory initialized.\n");return 0;
}

3. 生产者进程（写入共享内存）

生产者进程会不断生成数据并将其写入共享内存。当缓冲区满时，生产者会等待，直到消费者消费一些数据。

生产者代码 (producer.cpp)
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <pthread.h>
#include <string.h>
#include <ashmem.h>
#include "shared_memory.h"int main() {// 打开共享内存int fd = open("/dev/ashmem/my_shared_memory", O_RDWR);if (fd == -1) {perror("Failed to open shared memory");return -1;}// 映射共享内存struct shared_memory *shm = (struct shared_memory *)mmap(NULL, sizeof(struct shared_memory),PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);if (shm == MAP_FAILED) {perror("Failed to map shared memory");close(fd);return -1;}// 写入数据的生产者循环for (int i = 0; i < 100; ++i) {pthread_mutex_lock(&shm->mutex);// 如果缓冲区满，则等待while ((shm->write_index + 1) % BUFFER_SIZE == shm->read_index) {pthread_cond_wait(&shm->full_cond, &shm->mutex);}// 生成数据并写入缓冲区shm->buffer[shm->write_index] = i;printf("Producer: produced %d\n", i);// 更新写入位置shm->write_index = (shm->write_index + 1) % BUFFER_SIZE;// 通知消费者数据已准备好pthread_cond_signal(&shm->empty_cond);pthread_mutex_unlock(&shm->mutex);// 模拟生产者的工作时间sleep(1);}// 解除共享内存映射munmap(shm, sizeof(struct shared_memory));close(fd);return 0;
}

4. 消费者进程（读取共享内存）

消费者进程会从共享内存中读取数据并进行消费。当缓冲区为空时，消费者会等待，直到生产者写入数据。

消费者代码 (consumer.cpp)
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <pthread.h>
#include <string.h>
#include <ashmem.h>
#include "shared_memory.h"int main() {// 打开共享内存int fd = open("/dev/ashmem/my_shared_memory", O_RDWR);if (fd == -1) {perror("Failed to open shared memory");return -1;}// 映射共享内存struct shared_memory *shm = (struct shared_memory *)mmap(NULL, sizeof(struct shared_memory),PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);if (shm == MAP_FAILED) {perror("Failed to map shared memory");close(fd);return -1;}// 消费者循环for (int i = 0; i < 100; ++i) {pthread_mutex_lock(&shm->mutex);// 如果缓冲区空，则等待while (shm->read_index == shm->write_index) {pthread_cond_wait(&shm->empty_cond, &shm->mutex);}// 从缓冲区读取数据int item = shm->buffer[shm->read_index];printf("Consumer: consumed %d\n", item);// 更新读取位置shm->read_index = (shm->read_index + 1) % BUFFER_SIZE;// 通知生产者可以继续写入pthread_cond_signal(&shm->full_cond);pthread_mutex_unlock(&shm->mutex);// 模拟消费者的工作时间sleep(1);}// 解除共享内存映射munmap(shm, sizeof(struct shared_memory));close(fd);return 0;
}

5. 编译和运行

首先编译这三个程序：init_shared_memory.cpp、producer.cpp 和 consumer.cpp。

g++ init_shared_memory.cpp -o init_shared_memory -lstdc++ -lpthread
g++ producer.cpp -o producer -lstdc++ -lpthread
g++ consumer.cpp -o consumer -lstdc++ -lpthread

然后，按照以下顺序执行：

  1. 初始化共享内存： 在任何生产者或消费者进程运行之前，先运行初始化共享内存的程序。

    ./init_shared_memory

  2. 启动生产者进程： 启动生产者进程，它会开始生成数据并写入共享内存。

    ./producer

  3. 启动消费者进程： 启动多个消费者进程，读取共享内存中的数据。

    ./consumer

    可以启动多个消费者进程，如：

    ./consumer &
./consumer &

总结

在这个例子中，我们使用了 条件变量 来实现生产者消费者模型。在每次写入和读取数据时，生产者和消费者会根据缓冲区的状态进行等待和通知，从而保证了数据的一致性。信号量可以用来控制资源的访问，而条件变量则提供了更灵活的同步机制，尤其是在等待和通知特定条件时。


http://www.ppmy.cn/server/154383.html

相关文章

React中常用的钩子

React中常用的钩子

在当今&#xff0c;React的钩子写法已经逐渐成为了一种主流开发模式&#xff0c;本文将介绍几种在React中常用的钩子 useState 可以用来双向绑定&#xff0c;创建需要监听变化并且使用的数据 使用该钩子定义时&#xff0c;参数可以是一个直接定义好的变量&#xff0c;也可以是…
阅读更多...
Linux | Ubuntu零基础安装 nvm 管理nodejs

Linux | Ubuntu零基础安装 nvm 管理nodejs

目录 介绍 项目地址 前置工具 安装 查看环境配置 更新环境变量 查看版本 查看 nodejs包 列表 安装nodejs 查看 nvm 状态 测试 nodejs 介绍 nvm是什么&#xff1f;你可以把它理解成 nodejs的管理软件&#xff0c;方便快速切换nodejs的版本&#xff0c;达到兼容状态 …
阅读更多...
数据的存储和处理——创建数组

数据的存储和处理——创建数组

今天是学习python的第二天&#xff0c;感觉已经从C的习惯中走出来了&#xff0c;适应了python语言的代码规则。今天主要学习Python中Numpy模块中的array()函数以及arange()函数&#xff0c;以及random子模块下的rand()函数、randn()函数&#xff0c;randint()函数。由于函数比较…
阅读更多...
交换机与路由器的区别

交换机与路由器的区别

交换机和路由器是网络中的两种关键设备&#xff0c;它们各自承担不同的功能&#xff0c;主要区别体现在以下几个方面&#xff1a; 一、工作层次与功能 交换机&#xff1a; 工作层次&#xff1a;交换机主要工作在OSI模型的第二层&#xff0c;即数据链路层。 功能&#xff1a;交…
阅读更多...
LeetCode -Hot100 - 56. 合并区间

LeetCode -Hot100 - 56. 合并区间

前言 本专栏主要通过“LeetCode 热题100”&#xff0c;来捡起自己本科阶段的算法知识与技巧。语言主要使用c/java。如果同样正在练习LeetCode 热题100的朋友欢迎关注或订阅本专栏。有疑问欢迎留言交流~ 题目描述 题目链接 给定一个整数数组 nums&#xff0c;将数组中的元素…
阅读更多...
WPF编程excel表格操作

WPF编程excel表格操作

WPF编程excel表格操作 摘要NPOI安装封装代码测试代码 摘要 Excel操作几种方式 使用开源库NPOI(常用&#xff0c;操作丰富)使用Microsoft.Office.Interop.Excel COM组件(兼容性问题)使用OpenXml(效率高)使用OleDb(过时) NPOI安装 封装代码 using System; using System.IO; u…
阅读更多...
关键客户转化为会员的重要性及 “开源 AI 智能名片 2 + 1 链动模式商城小程序” 在其中的应用剖析

关键客户转化为会员的重要性及 “开源 AI 智能名片 2 + 1 链动模式商城小程序” 在其中的应用剖析

摘要&#xff1a; 本文聚焦于商业运营中把关键客户转化为会员的重要意义&#xff0c;深入探讨在此过程中新兴技术与模式的作用。以 “开源 AI 智能名片 2 1 链动模式商城小程序” 为例&#xff0c;阐述其如何助力企业精准识别、转化关键客户为会员&#xff0c;实现营销的精准化…
阅读更多...
指针学习-

指针学习-

指针基础 &#xff08;1&#xff09;p (int *) 1732——p指向地址为1732的int变量 &#xff08;2&#xff09;指针声明符不是指针的组成部分&#xff0c;p是指针变量而不是*p &#xff08;3&#xff09;不同类型的指针变量之间不能相互赋值 &#xff08;4&#xff09;指针初始…
阅读更多...
最新文章

Copyright @ 2022~2023