VS2010 CUDA和C++混合編譯

阿新 • • 發佈：2019-02-01

在做專案整合的時候需要用到cpp和cuda檔案聯調，自己摸索了兩種方式實現cpp和cu檔案混合編譯。

本文環境：

windows7 64位
VS2010
CUDA5.5
英偉達顯示卡Tesla C1060

前言

裝好CUDA 5.5 sdk後，預設會自動新增好系統環境變數。

因此不需要額外配置，不過為了保險起見，可以選擇性地新增以下環境變數：

CUDA_BIN_PATH　　%CUDA_PATH%\bin
CUDA_LIB_PATH　　%CUDA_PATH%\lib\Win32
CUDA_SDK_BIN　　%CUDA_SDK_PATH%\bin\Win32
CUDA_SDK_LIB　　%CUDA_SDK_PATH%\common\lib\Win32
CUDA_SDK_PATH　　C:\cuda\cudasdk\common

這時可以開啟CUDA自帶的sample執行一下，執行能通過才可以繼續下面的內容————cpp和cuda聯調。

方法一：先建立cuda工程，再新增cpp檔案

1.開啟vs2010，新建一個cuda專案，名稱CudaCpp。

2.cuda預設建立的工程是如下，實現了兩個一維向量的並行相加。kernel函式和執行函式還有main函式全都寫在了一個cu檔案裡。

3.接下來在工程裡新增一個空的cpp檔案。將原來cu檔案裡main函式裡的內容剪下到cpp檔案main函式裡。

為了讓cpp能夠呼叫cu檔案裡面的函式，在addWithCuda函式前加上extern "C"關鍵字（注意C大寫，為什麼addKernel不用加呢？因為cpp裡面直接呼叫的是addWithCuda）

4.在cpp裡也要加上addWithCuda函式的完整前向宣告。下圖就是工程的完整結構

5.可以在cpp裡的main函式return之間加入getchar()防止執行後一閃就退出，加上system("pause")或者直接ctrl+F5也行。

執行結果：

下面貼出CudaCpp專案程式碼。

kernel.cu

[plain] view plain copy print?

#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <stdio.h>
__global__ void addKernel(int *c, const int *a, const int *b)
{
int i = threadIdx.x;
c[i] = a[i] + b[i];
}
// Helper function for using CUDA to add vectors in parallel.
extern "C"
cudaError_t addWithCuda(int *c, const int *a, const int *b, unsigned int size)
{
int *dev_a = 0;
int *dev_b = 0;
int *dev_c = 0;
cudaError_t cudaStatus;
// Choose which GPU to run on, change this on a multi-GPU system.
cudaStatus = cudaSetDevice(0);
if (cudaStatus != cudaSuccess) {
fprintf(stderr, "cudaSetDevice failed! Do you have a CUDA-capable GPU installed?");
goto Error;
}
// Allocate GPU buffers for three vectors (two input, one output) .
cudaStatus = cudaMalloc((void**)&dev_c, size * sizeof(int));
if (cudaStatus != cudaSuccess) {
fprintf(stderr, "cudaMalloc failed!");
goto Error;
}
cudaStatus = cudaMalloc((void**)&dev_a, size * sizeof(int));
if (cudaStatus != cudaSuccess) {
fprintf(stderr, "cudaMalloc failed!");
goto Error;
}
cudaStatus = cudaMalloc((void**)&dev_b, size * sizeof(int));
if (cudaStatus != cudaSuccess) {
fprintf(stderr, "cudaMalloc failed!");
goto Error;
}
// Copy input vectors from host memory to GPU buffers.
cudaStatus = cudaMemcpy(dev_a, a, size * sizeof(int), cudaMemcpyHostToDevice);
if (cudaStatus != cudaSuccess) {
fprintf(stderr, "cudaMemcpy failed!");
goto Error;
}
cudaStatus = cudaMemcpy(dev_b, b, size * sizeof(int), cudaMemcpyHostToDevice);
if (cudaStatus != cudaSuccess) {
fprintf(stderr, "cudaMemcpy failed!");
goto Error;
}
// Launch a kernel on the GPU with one thread for each element.
addKernel<<<1, size>>>(dev_c, dev_a, dev_b);
// Check for any errors launching the kernel
cudaStatus = cudaGetLastError();
if (cudaStatus != cudaSuccess) {
fprintf(stderr, "addKernel launch failed: %s\n", cudaGetErrorString(cudaStatus));
goto Error;
}
// cudaDeviceSynchronize waits for the kernel to finish, and returns
// any errors encountered during the launch.
cudaStatus = cudaDeviceSynchronize();
if (cudaStatus != cudaSuccess) {
fprintf(stderr, "cudaDeviceSynchronize returned error code %d after launching addKernel!\n", cudaStatus);
goto Error;
}
// Copy output vector from GPU buffer to host memory.
cudaStatus = cudaMemcpy(c, dev_c, size * sizeof(int), cudaMemcpyDeviceToHost);
if (cudaStatus != cudaSuccess) {
fprintf(stderr, "cudaMemcpy failed!");
goto Error;
}
Error:
cudaFree(dev_c);
cudaFree(dev_a);
cudaFree(dev_b);
return cudaStatus;
}

#include "cuda_runtime.h"
#include "device_launch_parameters.h"

#include <stdio.h>

__global__ void addKernel(int *c, const int *a, const int *b)
{
    int i = threadIdx.x;
    c[i] = a[i] + b[i];
}
// Helper function for using CUDA to add vectors in parallel.
extern "C"
cudaError_t addWithCuda(int *c, const int *a, const int *b, unsigned int size)
{
    int *dev_a = 0;
    int *dev_b = 0;
    int *dev_c = 0;
    cudaError_t cudaStatus;

    // Choose which GPU to run on, change this on a multi-GPU system.
    cudaStatus = cudaSetDevice(0);
    if (cudaStatus != cudaSuccess) {
        fprintf(stderr, "cudaSetDevice failed!  Do you have a CUDA-capable GPU installed?");
        goto Error;
    }

    // Allocate GPU buffers for three vectors (two input, one output)    .
    cudaStatus = cudaMalloc((void**)&dev_c, size * sizeof(int));
    if (cudaStatus != cudaSuccess) {
        fprintf(stderr, "cudaMalloc failed!");
        goto Error;
    }

    cudaStatus = cudaMalloc((void**)&dev_a, size * sizeof(int));
    if (cudaStatus != cudaSuccess) {
        fprintf(stderr, "cudaMalloc failed!");
        goto Error;
    }

    cudaStatus = cudaMalloc((void**)&dev_b, size * sizeof(int));
    if (cudaStatus != cudaSuccess) {
        fprintf(stderr, "cudaMalloc failed!");
        goto Error;
    }

    // Copy input vectors from host memory to GPU buffers.
    cudaStatus = cudaMemcpy(dev_a, a, size * sizeof(int), cudaMemcpyHostToDevice);
    if (cudaStatus != cudaSuccess) {
        fprintf(stderr, "cudaMemcpy failed!");
        goto Error;
    }

    cudaStatus = cudaMemcpy(dev_b, b, size * sizeof(int), cudaMemcpyHostToDevice);
    if (cudaStatus != cudaSuccess) {
        fprintf(stderr, "cudaMemcpy failed!");
        goto Error;
    }

    // Launch a kernel on the GPU with one thread for each element.
    addKernel<<<1, size>>>(dev_c, dev_a, dev_b);

    // Check for any errors launching the kernel
    cudaStatus = cudaGetLastError();
    if (cudaStatus != cudaSuccess) {
        fprintf(stderr, "addKernel launch failed: %s\n", cudaGetErrorString(cudaStatus));
        goto Error;
    }
    
    // cudaDeviceSynchronize waits for the kernel to finish, and returns
    // any errors encountered during the launch.
    cudaStatus = cudaDeviceSynchronize();
    if (cudaStatus != cudaSuccess) {
        fprintf(stderr, "cudaDeviceSynchronize returned error code %d after launching addKernel!\n", cudaStatus);
        goto Error;
    }

    // Copy output vector from GPU buffer to host memory.
    cudaStatus = cudaMemcpy(c, dev_c, size * sizeof(int), cudaMemcpyDeviceToHost);
    if (cudaStatus != cudaSuccess) {
        fprintf(stderr, "cudaMemcpy failed!");
        goto Error;
    }

Error:
    cudaFree(dev_c);
    cudaFree(dev_a);
    cudaFree(dev_b);
    
    return cudaStatus;
}

main.cpp [cpp] view plain copy print?

#include <stdio.h>
#include "cuda_runtime.h"
#include "device_launch_parameters.h"
extern"C"
cudaError_t addWithCuda(int *c, constint *a, constint *b, unsigned int size);
int main()
{
constint arraySize = 5;
constint a[arraySize] = { 1, 2, 3, 4, 5 };
constint b[arraySize] = { 10, 20, 30, 40, 50 };
int c[arraySize] = { 0 };
// Add vectors in parallel.
cudaError_t cudaStatus = addWithCuda(c, a, b, arraySize);
if (cudaStatus != cudaSuccess) {
fprintf(stderr, "addWithCuda failed!");
return 1;
}
printf("{1,2,3,4,5} + {10,20,30,40,50} = {%d,%d,%d,%d,%d}\n",
c[0], c[1], c[2], c[3], c[4]);
printf("cuda工程中呼叫cpp成功！\n");
// cudaDeviceReset must be called before exiting in order for profiling and
// tracing tools such as Nsight and Visual Profiler to show complete traces.
cudaStatus = cudaDeviceReset();
if (cudaStatus != cudaSuccess) {
fprintf(stderr, "cudaDeviceReset failed!");
return 1;
}
getchar(); //here we want the console to hold for a while
return 0;
}

#include <stdio.h>
#include "cuda_runtime.h"
#include "device_launch_parameters.h"

extern "C"
	cudaError_t addWithCuda(int *c, const int *a, const int *b, unsigned int size);
int main()
{
	const int arraySize = 5;
	const int a[arraySize] = { 1, 2, 3, 4, 5 };
	const int b[arraySize] = { 10, 20, 30, 40, 50 };
	int c[arraySize] = { 0 };

	// Add vectors in parallel.
	cudaError_t cudaStatus = addWithCuda(c, a, b, arraySize);
	if (cudaStatus != cudaSuccess) {
		fprintf(stderr, "addWithCuda failed!");
		return 1;
	}

	printf("{1,2,3,4,5} + {10,20,30,40,50} = {%d,%d,%d,%d,%d}\n",
		c[0], c[1], c[2], c[3], c[4]);
	printf("cuda工程中呼叫cpp成功！\n");

	// cudaDeviceReset must be called before exiting in order for profiling and
	// tracing tools such as Nsight and Visual Profiler to show complete traces.
	cudaStatus = cudaDeviceReset();
	if (cudaStatus != cudaSuccess) {
		fprintf(stderr, "cudaDeviceReset failed!");
		return 1;
	}
	getchar(); //here we want the console to hold for a while
	return 0;
}

方法二：先建立cpp工程，再新增cu檔案

方法一由於是cuda工程是自動建立的，所以比較簡單，不需要多少額外的配置。而在cpp工程裡面新增cu就要複雜一些。為了簡單起見，這裡採用console程式講解，至於MFC或者Direct3D程式同理。

1.建立一個空的win32控制檯工程，名稱CppCuda。

2.然後右鍵工程-->新增一個cu檔案

3.將方法一中cu和cpp檔案的程式碼分別拷貝到這個工程裡來（做了少許修改，extern "C"關鍵字和某些標頭檔案不要忘了加），工程結構如圖：

這個時候編譯是通不過的，需要作一些配置。

4.關鍵的一步，右鍵工程-->生成自定義，將對話方塊中CUDA5.5前面的勾打上。

這時點選工程-->屬性，會發現多了CUDA連結器這一項。

5.關鍵的一步，右鍵kernel.cu檔案-->屬性，在常規-->項型別裡面選擇CUDA C/C++（由於cu檔案是由nvcc編譯的，這裡要修改編譯連結屬性）

6.工程-->屬性-->連結器-->附加依賴項，加入cudart.lib

7.工具-->選項-->文字編輯器-->副檔名新增cu \cuh兩個副檔名

8.至此配置成功。執行一下：

9.為了更加確信cuda中的函式確實被呼叫，在main.cpp裡面呼叫cuda函式的地方加入了一個斷點。

單步執行一下。

可以看到程式跳到了cu檔案裡去執行了，說明cpp呼叫cuda函式成功。

貼上程式碼（其實跟方式一基本一樣，沒怎麼改），工程CppCuda

kernel.cu

[plain] view plain copy print?

#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <stdio.h>
//cudaError_t addWithCuda(int *c, const int *a, const int *b, unsigned int size);
__global__ void addKernel(int *c, const int *a, const int *b)
{
int i = threadIdx.x;
c[i] = a[i] + b[i];
}
// Helper function for using CUDA to add vectors in parallel.
extern "C"
cudaError_t addWithCuda(int *c, const int *a, const int *b, unsigned int size)
{
int *dev_a = 0;
int *dev_b = 0;
int *dev_c = 0;
cudaError_t cudaStatus;
// Choose which GPU to run on, change this on a multi-GPU system.
cudaStatus = cudaSetDevice(0);
if (cudaStatus != cudaSuccess) {
fprintf(stderr, "cudaSetDevice failed! Do you have a CUDA-capable GPU installed?");
goto Error;
}
// Allocate GPU buffers for three vectors (two input, one output) .
cudaStatus = cudaMalloc((void**)&dev_c, size * sizeof(int));
if (cudaStatus != cudaSuccess) {
fprintf(stderr, "cudaMalloc failed!");
goto Error;
}
cudaStatus = cudaMalloc((void**)&dev_a, size * sizeof(int));
if (cudaStatus != cudaSuccess) {
fprintf(stderr, "cudaMalloc failed!");
goto Error;
}
cudaStatus = cudaMalloc((void**)&dev_b, size * sizeof(int));
if (cudaStatus != cudaSuccess) {
fprintf(stderr, "cudaMalloc failed!");
goto Error;
}
// Copy input vectors from host memory to GPU buffers.
cudaStatus = cudaMemcpy(dev_a, a, size * sizeof(int), cudaMemcpyHostToDevice);
if (cudaStatus != cudaSuccess) {
fprintf(stderr, "cudaMemcpy failed!");
goto Error;
}
cudaStatus = cudaMemcpy(dev_b, b, size * sizeof(int), cudaMemcpyHostToDevice);
if (cudaStatus != cudaSuccess) {
fprintf(stderr, "cudaMemcpy failed!");
goto Error;
}
// Launch a kernel on the GPU with one thread for each element.
addKernel<<<1, size>>>(dev_c, dev_a, dev_b);
// Check for any errors launching the kernel
cudaStatus = cudaGetLastError();
if (cudaStatus != cudaSuccess) {
fprintf(stderr, "addKernel launch failed: %s\n", cudaGetErrorString(cudaStatus));
goto Error;
}
// cudaDeviceSynchronize waits for the kernel to finish, and returns
// any errors encountered during the launch.
cudaStatus = cudaDeviceSynchronize();
if (cudaStatus != cudaSuccess) {
fprintf(stderr, "cudaDeviceSynchronize returned error code %d after launching addKernel!\n", cudaStatus);
goto Error;
}
// Copy output vector from GPU buffer to host memory.
cudaStatus = cudaMemcpy(c, dev_c, size * sizeof(int), cudaMemcpyDeviceToHost);
if (cudaStatus != cudaSuccess) {
fprintf(stderr, "cudaMemcpy failed!");
goto Error;
}
Error:
cudaFree(dev_c);
cudaFree(dev_a);
cudaFree(dev_b);
return cudaStatus;
}

#include "cuda_runtime.h"
#include "device_launch_parameters.h"

#include <stdio.h>

//cudaError_t addWithCuda(int *c, const int *a, const int *b, unsigned int size);
__global__ void addKernel(int *c, const int *a, const int *b)
{
    int i = threadIdx.x;
    c[i] = a[i] + b[i];
}
// Helper function for using CUDA to add vectors in parallel.
extern "C"
cudaError_t addWithCuda(int *c, const int *a, const int *b, unsigned int size)
{
    int *dev_a = 0;
    int *dev_b = 0;
    int *dev_c = 0;
    cudaError_t cudaStatus;

    // Choose which GPU to run on, change this on a multi-GPU system.
    cudaStatus = cudaSetDevice(0);
    if (cudaStatus != cudaSuccess) {
        fprintf(stderr, "cudaSetDevice failed!  Do you have a CUDA-capable GPU installed?");
        goto Error;
    }

    // Allocate GPU buffers for three vectors (two input, one output)    .
    cudaStatus = cudaMalloc((void**)&dev_c, size * sizeof(int));
    if (cudaStatus != cudaSuccess) {
        fprintf(stderr, "cudaMalloc failed!");
        goto Error;
    }

    cudaStatus = cudaMalloc((void**)&dev_a, size * sizeof(int));
    if (cudaStatus != cudaSuccess) {
        fprintf(stderr, "cudaMalloc failed!");
        goto Error;
    }

    cudaStatus = cudaMalloc((void**)&dev_b, size * sizeof(int));
    if (cudaStatus != cudaSuccess) {
        fprintf(stderr, "cudaMalloc failed!");
        goto Error;
    }

    // Copy input vectors from host memory to GPU buffers.
    cudaStatus = cudaMemcpy(dev_a, a, size * sizeof(int), cudaMemcpyHostToDevice);
    if (cudaStatus != cudaSuccess) {
        fprintf(stderr, "cudaMemcpy failed!");
        goto Error;
    }

    cudaStatus = cudaMemcpy(dev_b, b, size * sizeof(int), cudaMemcpyHostToDevice);
    if (cudaStatus != cudaSuccess) {
        fprintf(stderr, "cudaMemcpy failed!");
        goto Error;
    }

    // Launch a kernel on the GPU with one thread for each element.
    addKernel<<<1, size>>>(dev_c, dev_a, dev_b);

    // Check for any errors launching the kernel
    cudaStatus = cudaGetLastError();
    if (cudaStatus != cudaSuccess) {
        fprintf(stderr, "addKernel launch failed: %s\n", cudaGetErrorString(cudaStatus));
        goto Error;
    }
    
    // cudaDeviceSynchronize waits for the kernel to finish, and returns
    // any errors encountered during the launch.
    cudaStatus = cudaDeviceSynchronize();
    if (cudaStatus != cudaSuccess) {
        fprintf(stderr, "cudaDeviceSynchronize returned error code %d after launching addKernel!\n", cudaStatus);
        goto Error;
    }

    // Copy output vector from GPU buffer to host memory.
    cudaStatus = cudaMemcpy(c, dev_c, size * sizeof(int), cudaMemcpyDeviceToHost);
    if (cudaStatus != cudaSuccess) {
        fprintf(stderr, "cudaMemcpy failed!");
        goto Error;
    }

Error:
    cudaFree(dev_c);
    cudaFree(dev_a);
    cudaFree(dev_b);
    
    return cudaStatus;
}

main.cpp [cpp] view plain copy print?

#include <iostream>
#include "cuda_runtime.h"
#include "device_launch_parameters.h"
usingnamespace std;
extern"C"
cudaError_t addWithCuda(int *c, constint *a, constint *b, unsigned int size);
int main(int argc,char **argv)
{
constint arraySize = 5;
constint a[arraySize] = { 1, 2, 3, 4, 5 };
constint b[arraySize] = { 10, 20, 30, 40, 50 };
int c[arraySize] = { 0 };
// Add vectors in parallel.
cudaError_t cudaStatus = addWithCuda(c, a, b, arraySize);
if (cudaStatus != cudaSuccess) {
fprintf(stderr, "addWithCuda failed!");
return 1;
}
cout<<"{1,2,3,4,5} + {10,20,30,40,50} = {"<<c[0]<<','<<c[1]<<','<<c[2]<<','<<c[3]<<'}'<<endl;
printf("cpp工程中呼叫cu成功！\n");
// cudaDeviceReset must be called before exiting in order for profiling and
// tracing tools such as Nsight and Visual Profiler to show complete traces.
cudaStatus = cudaDeviceReset();
if (cudaStatus != cudaSuccess) {
fprintf(stderr, "cudaDeviceReset failed!");
return 1;
}
system("pause"); //here we want the console to hold for a while
return 0;
}

#include <iostream>
#include "cuda_runtime.h"
#include "device_launch_parameters.h"
using namespace std;

extern "C"
	cudaError_t addWithCuda(int *c, const int *a, const int *b, unsigned int size);
int main(int argc,char **argv)
{
	const int arraySize = 5;
	const int a[arraySize] = { 1, 2, 3, 4, 5 };
	const int b[arraySize] = { 10, 20, 30, 40, 50 };
	int c[arraySize] = { 0 };

	// Add vectors in parallel.
	cudaError_t cudaStatus = addWithCuda(c, a, b, arraySize);
	if (cudaStatus != cudaSuccess) {
		fprintf(stderr, "addWithCuda failed!");
		return 1;
	}

	cout<<"{1,2,3,4,5} + {10,20,30,40,50} = {"<<c[0]<<','<<c[1]<<','<<c[2]<<','<<c[3]<<'}'<<endl;
	printf("cpp工程中呼叫cu成功！\n");

	// cudaDeviceReset must be called before exiting in order for profiling and
	// tracing tools such as Nsight and Visual Profiler to show complete traces.
	cudaStatus = cudaDeviceReset();
	if (cudaStatus != cudaSuccess) {
		fprintf(stderr, "cudaDeviceReset failed!");
		return 1;
	}
	system("pause"); //here we want the console to hold for a while
	return 0;
}

注意有時候編譯出問題，把 "device_launch_parameters.h"這個標頭檔案去掉就好了（去掉之後就不能調裡面的函式或變量了），至於為什麼，還不是很清楚。

以後將cu檔案加入到任何MFC，qt，D3D或者OpenGL等C++工程中步驟都是類似的。

VS2010 CUDA和C++混合編譯

在做專案整合的時候需要用到cpp和cuda檔案聯調，自己摸索了兩種方式實現cpp和cu檔案混合編譯。本文環境： windows7 64位VS2010CUDA5.5英偉達顯示卡Tesla C1060 前言裝好CUDA 5.5 sdk後，預設會自動新增好系統環境變數。因此不需要額外配置，不過

VS2010中CUDA和C++混合編譯（兩種方式）

在做專案整合的時候需要用到cpp和cuda檔案聯調，自己摸索了兩種方式實現cpp和cu檔案混合編譯。本文環境： windows7 64位VS2010CUDA5.5英偉達顯示卡Tesla C1060 前言裝好CUDA 5.5 sdk後，預設會自動新增好系統環境變數

Cmake+Ubuntu+CUDA+C混合編譯

一. 環境Jetson TK1 開發套件+Ubuntu 14.04Cmake安裝：sudo apt-get install cmake二.示例1.目錄樹2.原始碼/cuda/cube.cu#include "cuda_runtime.h" #include "device_l

C++, Java和C#的編譯過程解析

非託管環境的編譯過程（C/C++）純C/C++的程式通常執行在一個非託管環境中，類是由標頭檔案（.h）和實現檔案（.cpp）組成，每個類形成了一個單獨的編譯單元，當我們編譯程式時，幾個基本元件會把我們的原始碼翻譯成二進位制程式碼，接下來我們通過以下圖片說明非託管

Halcon和C#混合程式設計（一）：數字識別

Halcon匯出C#程式碼 using System; using HalconDotNet; public partial class HDevelopExport { public HTuple hv_ExpDefaultWinHandle; //

matlab和c++混合程式設計---matlab和vs的環境配置問題及方法和步驟（轉載）

matlab和c++混合程式設計---方法和步驟 matlab和c++混合程式設計---matlab和vs的環境配置問題摘要：Matlab具有很強的數值計算和分析等能力,而C/C++是目前最為流行的高階程式設計語言,兩者互補結合的混合程式設計在科學研究和工程實踐中具有非常重要的意義。從Matlab呼叫C

scala 和Java混合編譯

scala和Java混合編譯的時候會出現問題，如果Java中引用scala的包，那麼會在編譯的時候報錯找不到相關類。原因這種問題是因為沒有先編譯scala，在編譯Java的時候找不到sc

matlab和c++混合程式設計---Mex結構和mexFunction引數傳遞

最近的專案需要matlab和C的混合程式設計，經過一番努力終於完成了專案要解決的問題。現在就將Mex的一些經驗總結一下，當然只是剛剛開始，以後隨著學習的深入繼續新增。首先講講寫Mex的一些常規規定，然後我們會重點關注混合程式設計中最難解決資料的問題--結構到底如何轉換

C與C++混合編譯

C語言與C++的函式編譯後的命名規則不同，因此在C++工程中直接引用C實現的原始碼會存在“undefined reference”問題，即找不到函式的實現。因此，在C的標頭檔案前，應使用extern “C”提示編譯器，該程式碼是使用C語言進行編寫的，如以下形式： ext

Matlab和C++混合程式設計——在matlab除錯過程中可以跳入VS除錯觀察.cpp檔案中的資料

1.在matlab中為.cpp使用mex編譯生成.mexw64(64位)檔案在matlab中封裝編譯函式: compile_gc(debug_flag) compile_gc(debug_flag=1):生成兩種檔案，（.mexw64和.mexw64.pdb） compi

matlab和c++混合程式設計---方法和步驟

　　摘要：Matlab具有很強的數值計算和分析等能力,而C/C++是目前最為流行的高階程式設計語言,兩者互補結合的混合程式設計在科學研究和工程實踐中具有非常重要的意義。從Matlab呼叫C/C++程式碼及C/C++呼叫m檔案兩方面,深入地研究了它們之間混合程式設計的原理和

vs2010 建立和C#使用動態連結庫(dll)

一、VS 用 C++ 建立動態連結庫 Step 1：建立Win32 Console Application 本例中我們建立一個叫做“Test”的Solution。 Step 2：將Ap

C++基礎學習筆記----第六課（const和引用的擴充套件、過載函式和C方式編譯的深入）

主要講了const和引用的一些擴充套件和注意事項，過載函式的和extren "C"結合使用的本質，以及引用的真正的理解方式。 const的引用擴充套件使用方法 1.通過const引用的變數是隻讀變數，當使用const_cast經過強制型別轉換後引用將會降級為普通變數，通過

STM32cubeMX改C/C++混合編譯

首先說明一下，本文的開發環境是linux,基於STM32cubeMX生成工程新增C++部分程式碼和選項。寫給微控制器開發windows轉linux新手,高手略過。cubeMX生成工程預設是C語言，還有一部分彙編。首先加入file.cpp到工程，在Middlewares下新建c

Qt5.8 QML和C++混合程式設計的兩種方式（附帶原始碼）

Qt5.8 QML和C++混合程式設計的兩種方式（附帶原始碼）編譯環境：win10 專業版 Qt5.8 Qt 提供了兩種在 QML 環境中使用 C++ 物件的方式：上手敲一下，很快就能理解點選開始，中間的圖形開始變化，上面顯示時間，

MATLAB和C++編譯器混合編譯：Xcode 8的不相容錯誤

最近在看tracking方面的論文和程式碼，發現大多數都是用matlab和c++混合編譯的。對於linux和windows這兩個系統，暫時還沒有碰到編譯器不相容的問題，但是mac上面卻有問題，在命令列裡輸入： mex -setup 會有下面的錯誤提示：

混合編譯：c++檔案呼叫c檔案變數和函式、c檔案呼叫c++檔案變數和函式

1.c++檔案呼叫c檔案變數和函式前言：以前見到extern "C"這樣的語句，只是簡單地知道跟外部連結有關，但是沒有深刻理解它的意思。首先，為什麼要使用extern "C"修飾符？ C++呼叫其它語言的函式，由於編譯器生成函式的機制不一樣，所以需要經過特殊處理，才可以

如何在VS2010中執行編譯C和C++

VS2010 需要先建立工程，然後在工程中新增cpp檔案，再編寫程式碼，然後編譯執行才可以，給您個圖吧： 1。首先新建專案 2。從左邊找到Visual C++ 在中間找到你要建立的專案，一般為空專案 3。分別在原始檔、標頭檔案新增你要新增的東西，新建

C和C++的混合編譯--extern “C”的使用

參考地址：http://www.cnblogs.com/skynet/archive/2010/07/10/1774964.html 在實際程式設計中，有時會需要用到C\C++的混合編譯，通過extern “C”即可實現混合編譯，以下是個人蔘照網友的資料以及自己的實際操作

Swift和Objective-C混合編程——Swift調用OC

分享發現 load 另一個 == 方法代碼 swift 應用在iOS應用的開發中。Swift必將代替OC，兩者的趨勢是“短期共存，長期代替”。但曾經有太多的代碼是用OC語言完畢的，而Swift的開發也從 OC中繼承了非常多的特性。兩者也是有非常多的類

VS2010 CUDA和C++混合編譯

前言

方法一：先建立cuda工程，再新增cpp檔案

方法二：先建立cpp工程，再新增cu檔案

相關推薦