java c\c++函数

C\c++语言函数 java 函数 c#函数 使用方法

C语言函数

进程 线程函数如下

fork 函数 (wait 函数将进程回收置空 )

简介 fork() 通过复制调用进程创建一个子进程

• 自进程有自己的id 而这个进程标识符（Process Identifier)PID 与任何现有进程组的ID都不匹配(也就是孤儿进程)
• 进程组：在某些操作系统中，进程可以被组织成组，称为进程组。进程组ID（PGID）用于标识这些组。

• ---

---

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main(){
    pid_t pid; //声明pid变量
    pid = fork(); //创建子进程
    if(pid > 0) { //fork失败
        printf("进程创建成功，子进程的pid为：%d\n");
        wait(NULL); //等待子进程结束 如果不加wait 子进程会成为僵尸进程 被init进程回收 
        printf("子进程结束，父进程继续执行\n");
    }
    if(pid == 0) { //子进程
        printf("我是子进程，我的父进程的pid为：%d\n");
    }
    if(pid < 0) { //fork失败
        printf("进程创建失败！\n");

    }
    printf("错误码：%d\n", pid);
    return 0;
}

**execl() 函数 家族: execlp execle execv execvp execvpe **

简介 exec family 作用是替换当前进程 执行成功不返回 发生错误会返回-1 当前进程会被替换掉

execl(const char *path, const char *arg,…); execlp(const char
*file, const char *arg,…);

1. file 替换的可执行文件的路径 “bin\sh”
2. const char *arg, 代表参数列表 …列表文件 /例子: execl(“bin/touch”,“touch”,“aaa.txt”,NULL) //NULL是末尾比>加的 我想要通过命令创建很多文件夹
   “bin/touch” 路径 “touch” 这是个命令(用于创建文件) “aaa.txt” 文件 他会在 bin/touch 下
   路径下创建一个aaaa.txt 文件 也可以是多个/

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    pid_t pid;
    pid = fork();
    if (pid > 0) {//负进程
        printf("负进程\n"); //提示语句
        wait(NULL); // 回收子进程
    }
    if (pid == 0) {//子进程
        execlp("bin/touch", "touch", "test.txt", NULL, NULL); //执行命令
        execlp("firefox","firefox",NULL); //这会打开火狐浏览器
        /*总结 如果在终端能打开 直接用execlp("firefox",NULL); 即可 如果是未配置变量环境则需要指定路径 如execlp("/usr/bin/firefox","firefox"NULL);*/
        printf("子进程\n"); //子进程输出语句

    }
    if (pid < 0) {
        printf("fork失败\n"); //提示语句
    }
    return 0;
}

execle(const char *path, const char *arg,......, char * const envp[]);
execv(const char *path, char *const argv[]);
execvp(const char *file, char *const argv[]);
execvpe(const char *file, char *const argv[], char *const envp[]);

memset 函数
简介 比较字符串函数

void* memset(void*_Dst, int _Val,size_t_size)

str1：第一个内存区域的起始地址。
str2：第二个内存区域的起始地址。
n：要比较的字节数。

返回值：

如果 str1 等于 str2，则返回 0。
如果 str1 在字典顺序上小于 str2，则返回一个小于 0 的值。
如果 str1 在字典顺序上大于 str2，则返回一个大于 0 的值。

#include <stdio.h>
#include <string.h>

int main() {
    char str1[] = "Hello";
    char str2[] = "World";
    int result = memcmp(str1, str2, 5); // 比较前5个字节
    if (result == 0) {  // 字符串不等于零的情况下
        printf("字符串是相等的。\n");
    } else {
        printf("字符串不相同\n");
    }
    return 0;
}

字符串函数如下

sizeof 函数

对比strlen函数 作用求（问）字符串内存长度

char p[4] = "abc";
printf("字符串：%s   sizeof长度：%d\n", p, sizeof(p));
printf("字符串：%s   strlen长度：%d\n", p, strlen(p));
/*
输出：
字符串：abc   sizeof长度：4
字符串：abc   strlen长度：3

sizeof 函数(字符串长度) 得长度比 strlen 函数(求去啦/0字符串长度)长度多1

char p1[] = "abcdefg"; //数组
printf("字符串：%s   sizeof长度：%d\n", p1, sizeof(p1));
printf("字符串：%s   strlen长度：%d\n", p1, strlen(p1));
printf("----------------------------\n");
char* p2 = "abcdefg"; //指针
printf("字符串：%s   strlen长度：%d\n", p2, strlen(p2));
printf("字符串：%s   sizeof长度：%d\n", p2, sizeof(p2));
/*
输出：
字符串：abcdefg   sizeof长度：8
字符串：abcdefg   strlen长度：7
----------------------------
字符串：abcdefg   strlen长度：7
字符串：abcdefg   sizeof长度：4
*/

== strcpy 函数语法 ==

/*
*描述：此类函数是用于对字符串进行复制（拷贝）。
*
*参数： 
*   [in] strSource：需要拷贝的字符串
*   [out] strDestination：拷贝完成之后的(目标)字符串
*   
*返回值：指向 strDestination 这个字符串的指针
*/
char* strcpy(char* strDestination, const char* strSource);
列子
#include <stdio.h>
#include <string.h>

int main() {
    char src[] = "Hello, World!";
    char dest[20]; // 确保dest足够大以容纳src的内容
    printf("Before copy: dest = '%s'\n", dest);
    strcpy(dest, src); // 将src复制到dest
    printf("After copy: dest = '%s'\n", dest);
    return 0;
}

strcpy_s 函数

#include <stdio.h>
#include <string.h>
#include <errno.h>

int main() {
    char src[] = "Hello, World!";
    char dest[20];
    errno_t err = strcpy_s(dest, sizeof(dest), src);
    
    if (err) {
        printf("String copy failed\n");
    } else {
        printf("Copied string: '%s'\n", dest);
    }
    
    return 0;
}

动态内存函数

c语言动态内存 管理

void* malloc (size_t size); //动态分配内存
void free (void* ptr); //销毁动态分配的内存
void* calloc (size_t num, size_t size);
void* realloc (void* ptr, size_t size);

== malloc 函数:动态分配内存==

#include <stdio.h>
#include <stdlib.h>

int main(){
    auto int muma = 20; //栈区
    int* p = &muma; //指针变量
    //自动申请堆区 成功返回堆区地址，失败返回NULL
    int* p2 = malloc(sizeof(int));  //堆区地址
    if(p2 == NULL){ //防御性编程
        printf("malloc 申请失败\n");
        return -1;
    }
    *p2 = 666; //堆区赋值
    printf("muma = %d\n", muma); //栈区值
    printf("p = %p\n", p); //栈区地址
    printf("p2 = %p\n", p2); //堆区地址
    printf("*p2 = %d\n", *p2); //堆区值
    free(p2); //释放堆区 不能重复释放
    p2 = NULL; //必须置空 你只是清楚了值 操作系统还会找到指针指向地址 
    

    return 0;
}

== 定义动态内存头文件的参数 ==

#include <limits.h>  定义动态内存的大小头文件

//malloc 如果开辟成功则指向一块指针地址 失败则返回一个NULL 空指针

//void* malloc (size_t size); //void 通用指针 可以接收任何类型 

int* p = (int*)malloc(INT_MAX); //INT_MAX 在#include <limits.h> 中有


//代码

//free 函数 内存销毁 一定要将地址指向空
free(p);
p = NULL;
一套标准写法

realloc 函数: 重新分配内存

void* calloc (size_t num, size_t size);


int main(){
      //int* pn = malloc(sizeof(int));  // 分配内存以存储一个整数
    int *pn = calloc(3, sizeof(int));  // 自动初始化内存空间
    if (pn == NULL){

        return -1;
    }
    *pn = 2;
    //relloc 函数重新分配内存
    if (!realloc(pn, sizeof(int) * 3))  // 重新分配存储3个整数的内存空间
    {
        return -1;
    }
    *(pn + 9) = 10;  // 向地址 pn + 9 存储整数值 10
    *(pn + 10) = 11;  // 向地址 pn + 10 存储整数值 11
    for (int i = 0; i < 11; i++){

        printf("%d ", *(pn + i));  // 打印存储在 pn 中的整数值
    }
    free(pn);  // 释放动态分配的内存空间
    return 0;

}

calloc 函数
介绍 用于动态分配内存并初始化为零。它通常用于分配一个数据结构（如数组或对象）的内存，确保所有元素都被初始化为零。calloc 定义在 或 <stdlib.h> 头文件中。

int main(int argc, char *argv[]){
    // 分配内存空间以存储10个整数
    int* p = (int*)calloc(10, sizeof (int));
    if (p == NULL)
    {
        // 如果内存分配失败，则打印错误信息并返回1
        printf("%s\n", strerror(errno));
        return 1;
    }
    // 打印分配内存空间中的初始值
    for (int i = 0; i < 10; i++)
        printf("%d ", *(p + i));

    // 释放动态分配的内存
    free(p);
    return 0;
}