CUDA编程二、C++和cuda混合编程的一些基础知识点

news2024/11/18 2:28:52

目录

一、C++运行过程

1、C++编译过程

2、代码运行示例

单文件 

多文件

a、编译所有cpp文件，但是不链接

b、链接所有的.o文件

c、运行程序

CMake编译

代码

使用方法

编译过程

代码运行

二、C++和cuda混合编程

cuda 单文件

cuda和C++多文件

手动分步编译

CMake编译

        上一篇博客CUDA编程一、基本概念和cuda向量加法，介绍了GPU结构和cuda编程的一些基础知识，最后用cuda实现了向量加法。这一篇博客中主要是学习C++和cuda混合编程的一些知识点，一是C++代码执行的过程，二是C++和cuda混合编程的实现。​​​​​​​

一、C++运行过程

        一直以来都是写python这种解释性语言，中间偶尔写过go语言，并没有对代码运行过程进行深入的研究，主要原因是python解释器会自动的编译代码；go语言在Goland这个IDE上也有可视化的按钮直接编译，就忽视了其中的一些细节。在学习C++编程的过程中，对于多文件怎么运行起来很不顺手。因此很有必要对C++代码运行过程进行一个比较详细的梳理。

1、C++编译过程

       和python解释性语言(运行过程中解释器逐行的把代码翻译为机器码)不同，C++语言代码需要在运行之前，自己手动的进行编译，完成代码到机器码转换的过程，得到最终可执行文件后，再执行代码实现逻辑。手动编译的过程中，主要是如下流程GCC Compilation Process：

如上图所示，整个流程分为4个步骤，针对一个cpp文件进行如下示意图过程：

预处理

对.cpp文件中的头文件、宏定义等做处理，展开这部分代码；清理注释；对条件编译做判定等。生成以.i文件

编译

把预处理的结果作为输入，生成和平台相关的汇编代码，输出.s文件，这是文本格式的。

汇编

就是汇编代码到机器码的过程，生成.o文件，这是一个二进制文件。

链接

将多个.o文件以及所需要的库文件还有.h文件链接到一起，形成最终的可执行文件。

2、代码运行示例

单文件 

当一个C++程序比较简单，只有一个CPP文件的时候，直接使用g++ 对单个文件进行编译即可，具体代码，简单的hello world，single_main.cpp。

#include<iostream>
int main(){
    std::cout<<"single_main hello world!"<<std::endl;
    return 0;
}

直接使用g++进行编译 一步到位

g++ single_main.cpp -o single_main          -o 指定编译后的文件名

运行结果如下：

多文件

这个才是常见的场景，就拿我学习C++的class示例来说，项目结果如下：

具体代码，

person.h

#ifndef PERSON_H
#define PERSON_H
#include<iostream>
using namespace std;

class Person
{
private:
    /* data */
public:
    string name;
    string ID;
    int age;
    string sex;
    float height;
    Person();
    Person(string name, string ID, int age,  string sex, float height);
    ~Person();
    void showInfo();
    void updateInfo(string name, string ID, int age,  string sex, float height);
    void speak(string sentence);
};

#endif

定义了一个person类，类里定义了公有变量和构造函数、析构函数、成员函数。

person.cpp

#include"person.h"

Person::Person(){
    std::cout<<"Person class object is being created by original class constructor without any paramters!"<<std::endl;
}

Person::Person(string name, string ID, int age,  string sex, float height){
    cout<<"Person class object is being created by original class constructor with paramters!"<<endl;
    this->age = age;
    this->height = height;
    this->ID = ID;
    this->name = name;
    this->sex = sex;
}

Person::~Person(){
    cout<<"Person 析构函数"<<endl;
}

void Person::showInfo(){
    cout<<"I am a person!" <<endl;
    cout<<"name:"<< this->name <<endl;
    cout<<"ID:"<< this->ID <<endl;
    cout<<"age:"<< this->age <<endl;
    cout<<"sex:"<< this->sex <<endl;
    cout<<"height:"<< this->height <<endl;
}

void Person::updateInfo(string name, string ID, int age,  string sex, float height){
    this->age = age;
    this->height = height;
    this->ID = ID;
    this->name = name;
    this->sex = sex;
}
void Person::speak(string sentence){
    cout<<sentence<<endl;
}

实现具体的函数逻辑

student.h

#ifndef STUDENT_H
#define STUDENT_H
#include<iostream>
# include"person.h"
using namespace std;

class Student:public Person
{
private:
    /* data */
    string address;
    string levlel;
public:
    Student();
    Student(string name, string ID, int age,  string sex, float height, string address, string levlel);
    ~Student();
    void showInfo();
    void updateInfo(string name, string ID, int age,  string sex, float height, string address, string levlel);
};
#endif

Student类继承Person类

student.cpp

#include <iostream>
#include"student.h"

Student::Student(){
    std::cout<<"class object is being created by original class constructor without any paramters!"<<std::endl;
}
Student::Student(string name, string ID, int age,  string sex, float height, string address, string levlel){
    cout<<"class object is being created by original class constructor with paramters!"<<endl;
    this->address = address;
    this->age = age;
    this->height = height;
    this->ID = ID;
    this->name = name;
    this->sex = sex;
    this->levlel = levlel;
}
Student::~Student(){
    cout<<"student 析构函数"<<endl;
}


void Student::updateInfo(string name, string ID, int age,  string sex, float height, string address, string levlel){
    this->address = address;
    this->age = age;
    this->height = height;
    this->ID = ID;
    this->name = name;
    this->sex = sex;
    this->levlel = levlel;
}
void Student::showInfo(){
    cout<<"I am a student and also a student!" <<endl;
    cout<<"name:"<< this->name <<endl;
    cout<<"ID:"<< this->ID <<endl;
    cout<<"age:"<< this->age <<endl;
    cout<<"sex:"<< this->sex <<endl;
    cout<<"height:"<< this->height <<endl;
    cout<<"address:"<< this->address <<endl;
    cout<<"levlel:"<< this->levlel <<endl;
    
}

成员函数进行重写

main.cpp

#include "person.h"
#include "student.h"

int main(void){
    string name = "黄洋";
    string ID = "0001";
    int age = 1;
    string sex = "男";
    float height = 172.5;
    Person *person = new Person(name, ID, age, sex, height);
    person->showInfo();
    person->speak("哈哈哈我会说话，我是黄洋！");

    string address = "湖北省武汉市洪山区";
    string level = "Level_0";
    cout<<address<<endl;
    Student * stu = new Student(name, ID, age, sex, height, address, level);
    stu->showInfo();
    height = 188.6;
    level = "Level_1";
    stu->updateInfo(name, ID, age, sex, height, address, level);
    stu->showInfo();
    stu->speak("我是学生，我也会说话！");
    delete person;
    delete stu;
    return 0;
}

调用这两个类完成任务。

编译的时候，就需要把所有的cpp都编译好，然后再链接在一起。

a、编译所有cpp文件，但是不链接

g++ main.cpp -c main.o   使用-c参数来进行编译

编译后得到3个.o文件，如下图

b、链接所有的.o文件

g++ main.o  person.o student.o  -o main

结果如下：

c、运行程序

./main

结果如下：

CMake编译

当然在开发C++项目的时候，不可避免有很多CPP文件，我们不可能一个一个的手动编译，可以使用cmake来生成makefile，然后使用make自动编译，这里就不做更多的说明了，给个示例

代码
cmake_minimum_required(VERSION 3.9)
project(class_study VERSION 1.0)
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED True)
set(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)
aux_source_directory(. src_list)
add_executable(${PROJECT_NAME} ${src_list})
使用方法
1、mkdir build 
2、cd ./build
3、 cmake .. 得到makefile makefile在build目录中
4、make  编译得到最终可执行文件在./bin目录下
编译过程

代码运行

和上述结果一模一样！

二、C++和cuda混合编程

C++和cuda一般都是混合在一起的，cuda代码.cu文件必须使用nvcc编译器来编译，C++的.cpp则必须使用g++等编译器来编译，混合的时候就需要手动的进行混合编译。

cuda 单文件

这个比较简单，C++代码和cuda代码全部写在一个.cu文件直接使用nvcc来编译就好了。引用CUDA编程一、基本概念和cuda向量加法中的向量加法示例来说明nvcc_vector_add.cu：​​​​​​​

#include<stdio.h>
#include<assert.h>
#include<cstdio>
#include<sys/time.h>
#include<iostream>
// 编译加链接
// nvcc -o nvcc_vector_add.cu  nvcc_vector_add.o
// 直接运行即可
// 向量加法核函数
__global__ void addVectorskernel(float *result, float *a, float *b, int N){
    int index = threadIdx.x + blockIdx.x * blockDim.x;
    int stride = blockDim.x * gridDim.x;
    for (int i=index; i<N; i+=stride){
        result[i] = a[i] + b[i]; // 元素a[i] + 元素 b[i]
    }
}

// 初始化数组 a
void initWith(float num, float *a, int N) {
    for(int i = 0; i < N; ++i) {
      a[i] = num;
    }
  };

int main(){
    const int N = 102400000;
    const int M = 10;
    size_t Mem = N * sizeof(float);
    float *a;
    float *b;
    float *c;

    cudaMallocManaged(&a, Mem);
    cudaMallocManaged(&b, Mem);
    cudaMallocManaged(&c, Mem);

    initWith(3.0, a, N); // 将数组a中所有的元素初始化为3
    initWith(4.0, b, N); // 将数组b中所有的元素初始化为4
    initWith(0.0, c, N); // 将数组c中所有的元素初始化为0，数组c是结果向量

    for(int i=0;i<M;i++){
        printf("%f ",a[i]);
    }
    printf("\n");
    printf("******************\n");
    for(int i=0;i<M;i++){
        printf("%f ",b[i]);
    }
    printf("\n");
    printf("******************\n");
    for(int i=0;i<M;i++){
        printf("%f ",c[i]);
    }
    printf("\n");
    printf("******************\n");

    // 配置参数
    size_t threadsPerBlock = 512;
    // size_t numberOfBlocks = (N + threadsPerBlock - 1) / threadsPerBlock;


    // numberOfBlocks 不小于GPU的SM梳理 4090有128个SM

    size_t numberOfBlocks = 10;

    struct timeval start;
    struct timeval end;
    gettimeofday(&start,NULL);
    addVectorskernel <<< numberOfBlocks, threadsPerBlock >>> (c, a, b, N); // 执行核函数
    cudaDeviceSynchronize(); // 同步，且检查执行期间发生的错误
    gettimeofday(&end,NULL);
    float time_use;
    time_use=(end.tv_sec-start.tv_sec)*1000000+(end.tv_usec-start.tv_usec);//微秒
    std::cout <<"vector_add gpu time cost is "<<time_use/1000/100<< " ms"<< std::endl;


    for(int i=0;i<M;i++){
        printf("%f ",a[i]);
    }
    printf("\n");
    printf("******************\n");
    for(int i=0;i<M;i++){
        printf("%f ",b[i]);
    }
    printf("\n");
    printf("******************\n");
    for(int i=0;i<M;i++){
        printf("%f ",c[i]);
    }
    printf("\n");
    printf("******************\n");
    return 0;
}

核函数以及核函数的调用逻辑都写在一个.cu文件里面，直接使用nvcc编译

//编译和链接
nvcc nvcc_vector_add.cu -o nvcc_vector_add  
 
//运行
./nvcc_vector_add

运行结果

cuda和C++多文件

一般大型一点的项目都会是多个文件的，.cu、.cuh和.cpp多个类型多个文件。这里我们人向量加法为例：

vector_add.cu文件实现核函数和核函数的调用函数(C++和cuda代码混合)

#include<stdio.h>
#include<assert.h>
#include<cstdio>
#include"vector_add.cuh"

// 向量加法核函数
__global__ void addVectorskernel(float *result, float *a, float *b, int N){
    int index = threadIdx.x + blockIdx.x * blockDim.x;
    int stride = blockDim.x * gridDim.x;
    for(int i=index; i<N; i+=stride){
        result[i] = a[i] + b[i]; // 元素a[i] + 元素 b[i]
    }
}

void addVectors(float *result, float *a, float *b, int N, size_t Mem){
    float *dev_a, *dev_b, *dev_c;
    //分类GPU内存
	cudaMalloc(&dev_a, Mem);    
	cudaMalloc(&dev_b, Mem);
	cudaMalloc(&dev_c, Mem);

    //将数据传给GPU
    cudaMemcpy(dev_a, a, Mem, cudaMemcpyHostToDevice);
    cudaMemcpy(dev_b, b, Mem, cudaMemcpyHostToDevice);
    
    addVectorskernel <<< 256, 1024 >>> (dev_c, dev_a, dev_b, N); // 执行核函数

    // 计算结果GPU到cpu
    cudaMemcpy(result, dev_c, Mem, cudaMemcpyDeviceToHost);
    cudaFree(dev_a);
    cudaFree(dev_b);
    cudaFree(dev_c);
}

addVectors该调用函数需要在vector_add.cuh中给出函数声明，同时还要使用extern "C"关键字，这样纯C++代码中就能调用addVectors函数，进而调用cuda核函数，进行向量加法运算。

#ifdef __cplusplus
extern "C" {
#endif
void addVectors(float *result, float *a, float *b, int N, size_t Mem);
#ifdef  __cplusplus
}
#endif

最后就是vector_add_gpu.cpp执行整个逻辑调用

#include<stdio.h>
#include<assert.h>
#include<cstdio>
#include<iostream>
#include"vector_add.cuh"
#include<sys/time.h>

// 混合编译步骤 -c不链接仅仅编译
// 1、nvcc -c vector_add.cu  ——得到vector_add.o
// 2、g++ -c vector_add_gpu.cpp  ——得到vector_add_gpu.o
// 3、链接lcudart
// g++ vector_add_main vector_add_gpu.o   vector_add.o  -lcudart  -L/usr/local/cuda-11.2/lib64

void initWith(float num, float *a, int N);

int main(){
    struct timeval start;
    struct timeval end;
    gettimeofday(&start,NULL);
    for (int i = 0;i < 100; i++){
        const int N = 10000000;
        size_t Mem = N * sizeof(float);
        float *a = new float[N];
        float *b = new float[N];
        float *c = new float[N];

        initWith(3.0, a, N); // 将数组a中所有的元素初始化为3
        initWith(4.0, b, N); // 将数组b中所有的元素初始化为4
        initWith(0.0, c, N); // 将数组c中所有的元素初始化为0，数组c是结果向量

        // 计算
        addVectors(c, a, b, N, Mem);
        if (i==99){
            printf("%f \n",c[0]);
        }
    }
    gettimeofday(&end,NULL);
    float time_use;
    time_use=(end.tv_sec-start.tv_sec)*1000000+(end.tv_usec-start.tv_usec);//微秒
    std::cout <<"vector_add gpu time cost is "<<time_use/1000/100<< " ms"<< std::endl;
    return 0;
}

// 初始化数组 a
void initWith(float num, float *a, int N) {
  for(int i = 0; i < N; ++i) {
    a[i] = num;
  }
};
手动分步编译
// 混合编译步骤 -c不链接仅仅编译
// 1、nvcc -c vector_add.cu  ——得到vector_add.o
// 2、g++ -c vector_add_gpu.cpp  ——得到vector_add_gpu.o
// 3、链接cuda  cudart
// g++  vector_add_gpu.o   vector_add.o  -lcudart  -L/usr/local/cuda-11.8/lib64 -o vector_add_main

编译过程和代码运行结果

CMake编译

当文件数多了以后，手动分步分文件编译，显然是个麻烦事儿不可靠，同样得使用cmake来编译，和上文cpp的cmake编译时CMakeList的语法有一点点差异，CMakeLists.txt代码如下：

cmake_minimum_required(VERSION 3.9)#Cmake最低版本
#project(demo LANGUAGES CXX CUDA) #这个写法也是可以的
project(demo)
enable_language(CUDA)#激活CUDA语言支持，使用第一个写法时要进行注释
#设置语言标准
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CUDA_STANDARD 11)

set(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)#设置编译后的程序存放位置
aux_source_directory(. SRC_LIST)#添加当前目录下的所有源文件

#编译列表
add_executable(${PROJECT_NAME} ${SRC_LIST})

编译过程和运行结果如下图：

编译过程完全自动化，不用自己手动的去分步编译。

和上述手动分步编译后，运行结果一样，耗时差不多。

参考文章

C/C++程序编译过程为什么要分为四个步骤？

详解C/C++代码的预处理、编译、汇编、链接全过程

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1251294.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

TDA笔记：夏克林老师，南洋理工大学

TDA笔记：夏克林老师，南洋理工大学

TDA比传统的统计方法有优势&#xff1a;benchmark中展现了这种优势 laplacian矩阵 多种单纯复形构造方式&#xff0c;可以构造出不同表征 二部图&#xff1a;Dowker complex Tor algebra可以用到多大数据 目前较新
阅读更多...
python教程：正常shell与反弹shell

python教程：正常shell与反弹shell

嗨喽&#xff0c;大家好呀~这里是爱看美女的茜茜呐 正常shell需要先在攻击端开机情况下开启程序,然后攻击端运行程序,才能连接 反弹shell,攻击端是服务端,被攻击端是客户端 正常shell,攻击端是客户端,被攻击端是服务端 反弹shell,先启用服务端,再启用客户端 反弹shell的好处…
阅读更多...
OPPO VOOC快充原理

OPPO VOOC快充原理

1 USB 3.0标准A插头 USB 3.0连接器是基于USB 2.0改进而来的&#xff0c;这个设计给USB 3.0连接器带来了一些潜在风险&#xff0c;如果USB 3.0设备插入主机的速度太慢&#xff0c;3.0的针脚还没来得及被识别到&#xff0c;就会被主机判定成USB 2.0的设备。 Figure 1-1 USB 3.0标…
阅读更多...
【C++】构造函数和析构函数第四部分（深拷贝和浅拷贝）--- 2023.11.25

【C++】构造函数和析构函数第四部分（深拷贝和浅拷贝）--- 2023.11.25

目录 什么是浅拷贝&#xff1f;浅拷贝的问题使用深拷贝解决浅拷贝问题结束语 什么是浅拷贝&#xff1f; 如果在一个类中没有人为定义拷贝函数&#xff0c;则系统会提供默认拷贝函数。那么在此默认拷贝函数中主要进行了简单的赋值操作&#xff0c;那这个简单的赋值操作我们一般…
阅读更多...
教师编制缩减是为什么

教师编制缩减是为什么

老师们有没有注意到一个趋势&#xff1f;那就是教师编制正在逐步缩减。不知道你们发现没有&#xff0c;我最近在研究教育领域的新闻&#xff0c;发现这两年教师编制缩减的消息越来越多。这是为什么呢&#xff1f;今天就来跟大家聊一聊。 原因一&#xff1a;资金压力 第一个原因…
阅读更多...
HarmonyOS应用开发实战—登录页面【ArkTS】

HarmonyOS应用开发实战—登录页面【ArkTS】

文章目录 本页面实战效果预览图一.HarmonyOS应用开发1.1HarmonyOS 详解1.2 ArkTS详解二.HarmonyOS应用开发实战—登录页面【ArkTS】2.1 ArkTS页面源码2.2 代码解析2.3 心得本页面实战效果预览图 一.HarmonyOS应用开发 1.1HarmonyOS 详解 HarmonyOS（鸿蒙操作系统）是华为公司…
阅读更多...
SD卡选型参考

SD卡选型参考

文档版本日期类型REV1.02023.11.25新建 SD卡对于大家来说&#xff0c;应该很熟悉了&#xff0c;都是我们在各类电子设备中经常使用的。不过大家在购买SD卡的时候都会关注哪些参数呢&#xff1f;可能大部分使用者&#xff0c;甚至包括我在内也只是会关注下容量&#xff0c;当然是…
阅读更多...
案例-某验四代滑块反爬逆向研究一

案例-某验四代滑块反爬逆向研究一

系列文章目录 第一部分 案例-某验四代滑块反爬逆向研究一 文章目录 系列文章目录前言一、分析流程二、定位 w 值生成位置三、device_id 值的定位生成四、pow_msg 值 和 pow_sign 值的生成总结 前言 本文章中所有内容仅供学习交流使用&#xff0c;不用于其他任何目的&#xff…
阅读更多...
性能优化中使用Profiler进行内存泄露的排查及解决方式

性能优化中使用Profiler进行内存泄露的排查及解决方式

文章目录 一、前言二、内存泄露的排查方式三、参考链接 一、前言 对于常规意义上的线程使用要及时关闭&#xff0c;数据库用完要及时关闭&#xff0c;数据用完要及时清空等等这里不再赘述&#xff0c;但是在开发中总会有不熟悉的api&#xff0c;开发进度过快&#xff0c;开发人…
阅读更多...
2022年09月 Scratch（三级）真题解析#中国电子学会#全国青少年软件编程等级考试

2022年09月 Scratch（三级）真题解析#中国电子学会#全国青少年软件编程等级考试

Scratch等级考试（1~4级）全部真题・点这里 一、单选题（共25题，每题2分，共50分） 第1题 运行下列程序后，结果为120的是？ A： B： C： D： 答案：C 本题考察阶乘知识，12345的结果为120. <
阅读更多...
redis持久化:RDB:和AOF

redis持久化:RDB:和AOF

目录 RDB 持久化 1、修改配置文件&#xff1a;redis.conf 2、RDB模式自动触发保存快照 3、RDB模式手动触发保存快照 4、RDB的优缺点 AOF持久化 1、AOF持久化工作流程 2、修改配置文件开启AOF 3、AOF优缺点 4、AOF的重写机制原理 RDBAOF混合模式 redis持久化有两种方…
阅读更多...
（2023码蹄杯）省赛（初赛）第三场真题（原题）（题解+AC代码)

（2023码蹄杯）省赛（初赛）第三场真题（原题）（题解+AC代码)

题目1&#xff1a;MC0227堆煤球 码题集OJ-堆煤球 (matiji.net) 思路&#xff1a; 1.i从l枚举到r,i是8的倍数就跳过&#xff0c;i不是8的倍数就用等差数列求和公式i(1i)/2,最后累加到答案中即可 AC_Code:C #include<bits/stdc.h> using namespace std;int main( ) {in…
阅读更多...
name 属性：提高 Vue 应用可维护性的关键

name 属性：提高 Vue 应用可维护性的关键

&#x1f90d; 前端开发工程师&#xff08;主业&#xff09;、技术博主&#xff08;副业&#xff09;、已过CET6 &#x1f368; 阿珊和她的猫_CSDN个人主页 &#x1f560; 牛客高级专题作者、在牛客打造高质量专栏《前端面试必备》 &#x1f35a; 蓝桥云课签约作者、已在蓝桥云…
阅读更多...
基于springboot实现乒乓球预约管理系统项目【项目源码】

基于springboot实现乒乓球预约管理系统项目【项目源码】

基于springboot实现乒乓球预约管理系统演示 系统的开发环境 浏览器&#xff1a;IE 8.1&#xff08;推荐6.0以上&#xff09; 开发使用语言&#xff1a;JAVA JDK版本&#xff1a;JDK_8 数据库管理系统软件&#xff1a;Mysql 运行平台&#xff1a;Windows 7 运行环境&#…
阅读更多...
【微服务专题】SpringBoot自动配置简单源码解析

【微服务专题】SpringBoot自动配置简单源码解析

目录 前言阅读对象阅读导航前置知识什么是自动配置0.1 基本概念0.2 SpringBoot中的【约定大于配置】0.3 从SpringMVC看【约定大于配置】0.4 从Redis看【约定大于配置】0.5 小结 笔记正文一、EnableAutoConfiguration源码解析二、SpringBoot常用条件注解源码解析2.1 自定义条件注…
阅读更多...
性能测试【一】：Jmeter的常用操作

性能测试【一】：Jmeter的常用操作

性能测试【一】&#xff1a;Jmeter的常用操作 一、使用命令行方式运行Jmeter1、为什么2、怎么用3、示例4、结果文件 二、生成动态报告1、准备2、命令3、报告示例4、报告释义 三、使用问题汇总 推荐使用命令行运行&#xff0c;GUI方式会经常卡死&#xff0c;尤其跑稳定性 一、使…
阅读更多...
《使用Python将Excel数据批量写入MongoDB数据库》

《使用Python将Excel数据批量写入MongoDB数据库》

在数据分析及处理过程中&#xff0c;我们经常需要将数据写入数据库。而MongoDB作为一种NoSQL数据库&#xff0c;其具有强大的可扩展性、高性能以及支持复杂查询等特性&#xff0c;广泛用于大规模数据存储和分析。在这篇文章中&#xff0c;我们将使用Python编写一个将Excel数据批…
阅读更多...
机器学习-线性回归

机器学习-线性回归

线性模型是一类用于建模输入特征与输出之间线性关系的统计模型。这类模型的基本形式可以表示为&#xff1a; 其中&#xff1a; 是模型的输出&#xff08;目标变量&#xff09;。 是截距&#xff08;常数项&#xff0c;表示在所有输入特征都为零时的输出值&#xff09;。 是权重…
阅读更多...
CCFCSP试题编号：202206-2试题名称：寻宝！大冒险！

CCFCSP试题编号：202206-2试题名称：寻宝！大冒险！

一、题目 二、分析 因为藏宝图左下角位置一定是一棵树&#xff0c;所以只要把所有绿化图中每一棵树&#xff0c;与之相匹配&#xff0c;然后判断&#xff0c;是否整个藏宝图都是绿化图的一部分&#xff0c;如果是那就计数count1。所以来看&#xff0c;结果count最大也就是n(绿…
阅读更多...
【c++j继承】

【c++j继承】

在编程领域中&#xff0c;面向对象是一种非常流行的程序设计方法。C 继承是面向对象编程中的一个重要概念&#xff0c;它允许我们创建一个新的类&#xff08;子类&#xff09;来继承已有的类&#xff08;父类&#xff09;的属性和方法。通过继承&#xff0c;我们可以实现代码的…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023