在linux中如何調用函數調用函數

① linux 下c語言怎樣調用C++的函數，怎麼編譯，舉個例子

完全和windows 下面沒有語法區別

在編譯之前我們需要在系統里安裝G++GCC，它們就是Linux下的C++/C的編譯器。代碼如下

代碼:

sudoapt-getinstallbuild-essential

sudoapt-getinstallgcc

sudoapt-getinstallg++

#include<iostream>

usingnamespacestd;

intmain()

{

cout<<"Hello,World! "<<endl;

return0;

}

另一個帶c++庫函數

#include<iostream>
#include<stack>
usingnamespacestd;
intsushu(intn)
{
inti;
for(i=2;i<n;i++)
{
if(n%i==0)
break;
}
if(n==i&&n!=1)
return1;
else
return0;
}
intmain()
{
intn,i,j;
stack<int>mystack;
cin>>n;
while(n>1)
{
for(i=2;i<=n;i++)
{
if(n%i==0&&sushu(i)==1)
{
mystack.push(i);
n=n/i;
break;
}
}
}
while(!mystack.empty())
{
cout<<mystack.top()<<"";
mystack.pop();
}
return0;
}

名稱為test.cpp

你使用

g++ test.cpp

./a.out

② Linux的庫函數是如何調用內核函數的

看系統調用，還有庫函數，以前一直不明白，總是以為 系統調用跟庫函數是一樣的，但是今天才知道是不一樣的。
庫函數也就是我們通常所說的應用編程介面API，它其實就是一個函數定義，比如常見read()、write()等函數說明了如何獲得一個給定的服務，但是系統調用是通過軟中斷向內核發出一個明確的請求，再者系統調用是在內核完成的，而用戶態的函數是在函數庫完成的。
系統調用發生在內核空間，因此如果在用戶空間的一般應用程序中使用系統調用來進行文件操作，會有用戶空間到內核空間切換的開銷。事實上，即使在用戶空間使用庫函數來對文件進行操作，因為文件總是存在於存儲介質上，因此不管是讀寫操作，都是對硬體（存儲器）的操作，都必然會引起系統調用。也就是說，庫函數對文件的操作實際上是通過系統調用來實現的。例如C庫函數fwrite()就是通過write()系統調用來實現的。
這樣的話，使用庫函數也有系統調用的開銷，為什麼不直接使用系統調用呢？這是因為，讀寫文件通常是大量的數據（這種大量是相對於底層驅動的系統調用所實現的數據操作單位而言），這時，使用庫函數就可以大大減少系統調用的次數。這一結果又緣於緩沖區技術。在用戶空間和內核空間，對文件操作都使用了緩沖區，例如用fwrite寫文件，都是先將內容寫到用戶空間緩沖區，當用戶空間緩沖區滿或者寫操作結束時，才將用戶緩沖區的內容寫到內核緩沖區，同樣的道理，當內核緩沖區滿或寫結束時才將內核緩沖區內容寫到文件對應的硬體媒介。
系統調用與系統命令：系統命令相對API更高一層，每個系統命令都是一個可執行程序，比如常用的系統命令ls、hostname等，比如strace ls就會發現他們調用了諸如open(),brk(),fstat(),ioctl()等系統調用。
系統調用是用戶進程進入內核的介面層，它本身並非內核函數，但他是由內核函數實現的，進入系統內核後，不同的系統調用會找到各自對應的內核函數，這寫內核函數被稱為系統調用的「服務常式」。也可以說系統調用是服務常式的封裝常式。

③ 紅帽linux中C語言編程如何調用數學函數

紅帽linux中C語言編程調用數學函數參考案例如下所示：
當需要調用函數的個數比較少時，可以直接在main函數中包含該文件，比如一個文件夾下包含add.c和main.c文件。
文件add.c定義兩個整數相加的函數,code如下：#include#includeintadd(inta,intb){intz；z=a+b；returnz；}，主函數main.c的code如下：#include#include#include"add.c"intmain(){inti,j,k；i=1；j=2；k=add(i,j)；printf("iaddj=%d",k)；}，編譯生成可執行文件：gcc-omainmain.c，執行：./main。

④ 在linux中 應用程序如何調用模塊內的函數

楹

⑤ 如何調用Linux內核函數

注意看這個文件
sysdeps/unix/sysv/linux/syscalls.list
裡面記錄著系統調用的名字和一些屬性，具體我也沒有研究過，不懂。
再看select的實現，很讓人驚訝，一旦使用，結果就是「報錯「。
int
__select (nfds, readfds, writefds, exceptfds, timeout)
int nfds;
fd_set *readfds;
fd_set *writefds;
fd_set *exceptfds;
struct timeval *timeout;
{
__set_errno (ENOSYS);
return -1;
}
libc_hidden_def (__select)
stub_warning (select)
weak_alias (__select, select)
這是因為glibc並沒有實現系統調用，而是調用系統調用，
更進一步，連調用系統調用都沒有一個個實現，而是使用了通用的辦法，
理由很簡單，所有的系統調用在linux內核頭文件里都能找到，
所有的系統調用參數類型就那麼幾種，參數個數也是有限的，
因此沒有必要針對所有的系統調用一一封裝，
於是就有了這個list文件，自動生成調用系統調用的函數，
如果生成失敗，也就是你看到的「報錯」。
符號是有強弱的，當自動生成成功的時候，「報錯」的弱符號就被忽略了。
當你在glibc中找到一個系統調用的封裝源碼，是以下原因，
1. 編譯的目標系統不支持這個系統調用，所以自己用另一種方式實現了。
2. 這個系統調用無法使用通用的自動生成方式生成，用特化的方式覆蓋。
3. 針對這個系統調用做了特別的優化。
4. 其它可能的原因。
具體可以留意
SYSCALL, PSEUDO, DO_CALL, INLINE_CALL 等名字
這兩個文件是重點所在
sysdeps/unix/i386/sysdep.h
sysdeps/unix/i386/sysdep.S
要搞清楚具體的自動生成過程，恐怕得研究glibc自身的編譯過程了

⑥ 在linux下，我想調用A.c裡面的某個函數，怎麼寫

在C裡面要先聲明，再使用。

看你主調函數（caller）跟被調函數（callee）是不是在同一個版文件中，以及兩者的權位置。
如果A.h中沒有聲明這個函數，那麼include沒有用。

如果你是編譯成了一個目標文件，你可以直接在caller定義前，加上callee的聲明。或者把callee的定義放在caller前定義。

⑦ 在linux中 應用程序如何調用模塊內的函數

很自然的，下一個疑問接踵而至，－－模塊里的其他函數如何被調用？比如我寫的模塊中除了 init_mole() 和cleanup_mole() 函數外，還寫了一個 hello_world() 函數，簡單的輸出hello world到控制台，好，接下來就是這次分析的關鍵，前面我們強調了模塊中的函數是由內核來調用的，除此之外沒有別的機會使它被執行到。那如果我們的 hello_world() 函數不能被內核調用，這不就意味著它永遠也不可能被執行到嗎？確實是這樣，換句話說，在這種情況下它就是一段垃圾代碼，永無見天日之時。怎麼樣才能使我們的 hello_world() 函數被執行？顯然，關鍵在於讓內核認識它，即內核能找到它。那麼，怎樣才能使內核找到這個函數？再進一步的問題是，內核為什麼要去找這個函數？
第一問的答案是，內核通過系統中特定的數據結構來找到函數的，當然，這意味著在你的模塊程序中，僅僅寫上 hello_world() 函數的代碼是不夠的，還應該再做幾步工作：
a，首先，系統中的各類數據結構那麼多，要使用哪個呢？這由你這個模塊的注冊性質決定，譬如你的模塊是一個USB設備驅動模塊，那麼你就需要填寫usb設備驅動程序的數據結構（通常數據結構都是結構體(struct)的形式）
struct usb_driver{第一項；第二項；第三項；.......}
這里的各項有些是字元串，有些是函數指針，具體請查資料。
b，把 hello_world() 的函數指針放進一個數據結構中。我們還是接著舉usb設備驅動程序模塊的例子吧，在它的數據結構usb_driver{}中，選一個恰好是函數指針的項，把 hello_world() 函數的指針放進去（通過函數名），再填滿這個數據結構的其他部分（不想填的話就空著吧:P，用分號分隔即可）。
c，填完之後，回到第一問中，怎樣使內核能夠找到這個 hello_world() 函數？回頭想想，當我們填完了數據結構，也就決定了我們所編的模塊的性質，在此例中它是作為一個usb設備驅動模塊，但是要讓內核知道它的性質，還得通過執行usb設備驅動程序的系統注冊函數 usb_register(struct usb_struct *drv)，向內核注冊這個模塊以及這個填好的數據結構。注意到了吧，注冊函數的參數就是我們前面所填寫的usb設備驅動模塊的數據結構，也就是說，執行了這個注冊函數之後，內核里就認識了這個模塊，並且得到了 hello_world() 函數的指針！哈哈，這就為我們的 hello_world() 函數找到了生存的意義－－它有可能被執行了！（偶覺得，程序生存的意義就在於被執行，就跟偶們生存的意義在於編程序一樣:P）
d，還得補充一下，usb_register(struct usb_struct *drv) 函數必須被放在 init_mole() 中，因為在注冊這個決定模塊性質的數據結構之前（短語太長，可約為這個數據結構），模塊中可以被直接執行到的函數只有 init_mole() 和 cleanup_mole() 兩個，如果不把握這個機會趕緊注冊數據結構的話，那我們的 hello_world() 函數又要永不見天日了:(。
現在來看第二問，內核為什麼要去找這個函數？還是用usb設備驅動模塊來解釋，其他類型的模塊偶不了解，還請大蝦們補充。對於usb設備驅動模塊，內核找這個函數的原因當然是，用戶程序對usb設備進行了某種操作，而這種操作需要usb設備驅動程序的函數來進行實現。我們前面的工作中已將這個usb設備驅動模塊的數據結構注冊進內核數據結構鏈表，內核根據我們這個模塊對應的數據結構usb_driver的各項定義，找到對應用戶要求的那個操作的那個函數。假設我們把 hello_world() 函數的指針放在usb_driver的 write() 選項中，那麼當用戶對usb設備進行寫操作的時候，就調用了 hello_world() 函數，控制台屏幕上會打出hello world ，其他什麼操作都沒有，哈哈，一定很有趣。(這里我們假設此usb設備的驅動程序正好是我們編的那個）
自己的一點心得，大部分是憑空想像的，錯誤之處一定數不勝數，還請各位大蝦費心批評指教！

⑧ 如何在linux調用windows庫函數

在linux調用windows庫函數：它之所以能夠在windows上運行，當然是因為編譯器把它們編譯成了windows操作系統能夠識別的機器碼組織形式。

應先用fdisk –l或 more /proc/partitions查看系統的硬碟和硬碟分區情況。

#mount -t ntfs /dev/sdc1 /mnt/usbhd1。

#mount -t vfat /dev/sdc5 /mnt/usbhd2。

註：對ntfs格式的磁碟分區應使用-t ntfs 參數，對fat32格式的磁碟分區應使用-t vfat參數。

find：

find / -name "*.txt" -print 用於查找所有的『 *.txt』文件在當前目錄及子目錄中。

find / -name "[A-Z]*" -print 用於當前目錄及子目錄中查找文件名以一個大寫字母開頭的文件。

find /etc -name "host*" -print 在/etc目錄中查找文件名以host開頭的文件。

find / -name "[a-z][a-z][0--9][0--9].txt" -print 在當前目錄查找文件名以兩個小寫字母開頭，跟著是兩個數字，最後是.txt的文件。

⑨ Linux系統函數調用

指令很多,你只襲要記住常用的就行了,其它的用到了在查閱

我舉幾個常用的命令
查看cpu cat /proc/cpuinfo
查看內存 free -m
查看掛載的硬碟 df -h
查看所有硬碟 fdisk -l
復制
移動 mv
打開目錄 cd 目錄名稱
cat 查看文件內容
more 分屏查看內容
head 查看文件開頭部分內容
tail 查看文件結尾部分內容
mail 查看當前用戶的郵件
等等

⑩ 在Linux下，在C中怎麼調用C++的庫函數

調用C++函數庫，一般不能直接調用，需要將C++庫轉換成C介面輸出，方可以使用C調用
將 C++ 函數聲明為``extern "C"''（在你的 C++ 代碼里做這個聲明），然後調用它（在你的 C 或者 C++ 代碼里調用）。例如：
// C++ code:
extern "C" void f(int);
void f(int i)
{
// ...
}

然後，你可以這樣使用 f()：
/* C code: */
void f(int);
void cc(int i)
{
f(i);
/* ... */
}

當然，這招只適用於非成員函數。如果你想要在 C 里調用成員函數（包括虛函數），則需要提供一個簡單的包裝（wrapper）。例如：
// C++ code:
class C
{
// ...
virtual double f(int);
};

extern "C" double call_C_f(C* p, int i) // wrapper function
{
return p->f(i);
}

然後，你就可以這樣調用 C::f()：
/* C code: */
double call_C_f(struct C* p, int i);

void ccc(struct C* p, int i)
{
double d = call_C_f(p,i);
/* ... */
}

如果你想在 C 里調用重載函數，則必須提供不同名字的包裝，這樣才能被 C 代碼調用。例如：
// C++ code:
void f(int);
void f(double);

extern "C" void f_i(int i) { f(i); }
extern "C" void f_d(double d) { f(d); }

然後，你可以這樣使用每個重載的 f()：
/* C code: */

void f_i(int);
void f_d(double);

void cccc(int i,double d)
{
f_i(i);
f_d(d);
/* ... */
}
注意，這些技巧也適用於在 C 里調用 C++ 類庫，即使你不能（或者不想）修改 C++ 頭文件。

再看下面的例子：
aa.cxx
#include "aa.h"
int sample::method()
{
cout<<"method is called!\n";
}
aa.h
#include
using namespace std;
class sample
{
public:
int method();
};
將上面的兩個文件生成動態庫libaa.so放到 /usr/lib目錄下，編譯命令如下
sudo g++ -fpic -shared -g -o /usr/lib/libaa.so aa.cxx -I ./
由於在C中不能識別類，所以要將上面類的成員函數封裝成C介面函數輸出，下面進行封裝，將輸出介面轉換成C介面。
mylib.cxx
#include "add.h"
#ifndef _cplusplus
#define _cplusplus
#include "mylib.h"
#endif

int myfunc()
{
sample ss;
ss.method();
return 0;
}
mylib.h
#ifdef _cplusplus
extern "C"
{
#endif

int myfunc();

#ifdef _cplusplus
}
#endif
在linux下，gcc編譯器並沒用變數_cplusplus來區分是C代碼還是C++代碼，如果使用gcc編譯器，這里我們可以自己定義一個變數_cplusplus用於區分C和C++代碼，所以在mylib.cxx中定義了一個變數_cplusplus用於識別是否需要「extern "C"」將函數介面封裝成C介面。但是如果使用g++編譯器則不需要專門定義_cplusplus，編譯命令如下：
g++ -fpic -shared -g -o mylib.so mylib.cxx -la -I ./
main.c
#include
#include
#include "mylib.h"
int
main()
{
int (*dlfunc)();
void *handle; //定義一個句柄
handle = dlopen("./mylib.so", RTLD_LAZY);//獲得庫句柄
dlfunc = dlsym(handle, "myfunc"); //獲得函數入口
(*dlfunc)();
dlclose(handle);

return 0;
}
編譯命令如下：
gcc -o main main.c ./mylib.so -ldl
下面就可以執行了。
需要說明的是，由於main.c 和 mylib.cxx都需要包含mylib.h，並且要將函數myfunc封裝成C介面函數輸出需要「extern "C"」，而C又不識別「extern "C"」，所以需要定義_cplusplus來區別處理mylib.h中的函數myfunc。
在main.c的main函數中直接調用myfunc（）函數也能執行，這里介紹的是常規調用庫函數的方法。