随笔分类

随笔档案

阅读排行榜

C/C++ 编程

写一个函数找出一个整数数组中，第二大的数

int find_sec_max(int *data, int count) 
 { 
     int max = data[0]; 
     int sec_max = data[0]; 
     for (int i = 1; i < count; i++) 
     { 
         if (data[i] > max) 
         { 
             sec_max = max; 
             max = data[i]; 
         } 
         else 
         { 
             if (data[i] > sec_max) 
                 sec_max = data[i]; 
         } 
     }
 
     return sec_max; 
 }

求整型数组中的最小以及次小项。

void getMin(int *array, int size, int &resMin, int &resSecMin) {
    resMin = array[0];
    resSecMin = array[0];

    for (int i = 1; i < size; i++) {
        if (array[i] < resMin) {
            resSecMin = resMin;
            resMin = array[i];
        } else {
            if (array[i] < resSecMin) {
                resSecMin = array[i];
            }
        }
    }

}

判断大小端模式

小端模式：高字节保存高地址中，低字节保存在低地址中

以16位系统为例，如果c.b==1, 说明c.a的保存方式是0x0001, 低字节保存在低地址中。如果是大端模式，c.a的保存方式是0x0100，低字节保存在高地址中，则c.b == 0。

联合体union的存放顺序是所有成员都从低地址开始存放

 int CheckCpu()
 {
     union w
     {
         int a;
         char b;
     }c;
     c.a = 1;
     return (c.b == 1);
 }

求两个整数的最大公约数和最小公倍数。

枚举法思路：

找到a、b中的较小值
从该值开始，判断该数能否同时被a、b整除
若可以被整除返回该值
若不可以则递减1

// 求最大公约数
int gcd(int a, int b)
{
    int temp = a > b ? b : a;
    while (temp)
    {
        if (a % temp == 0 && b % temp == 0)
        {
            break;
        }
        --temp;
    }
    return temp;
}

最小公倍数求法就比较简单了，求出最大公因数后，用a*b/gcd(a,b)即可

写一个函数从字符串N中查找子串字符串M第一次出现的位置。

int FindString(const char *strN, const char *strM) {
    const char *pSrc = strN;
    const char *pSub = strM;
　　 if(pSub == NULL)
　　 {
　　　　return -1:
 　　}

    int iPos = 0;
    while (*pSrc != 0) {
        const char *pSrc0 = pSrc;
        do {
            if (*pSub == 0) {
                return iPos;
            }
        } while (*pSrc0++ == *pSub++);

        pSub = strM;
        pSrc++;

        iPos ++;
    }
    return -1;
}

获取内存

void GetMemory1(char *p, int num) {
    p = (char *)malloc(sizeof(char) * num);
}

运行结果：运行错误
解释：GetMemory1(char *p, int num)中的函数参数是char *p类型的，而传入函数的str的类型也是char *。这就导致了，调用GetMemory(str);后，最终str的值还是NULL，在函数内部修改形参并不能真正改变传递进去的实参。简单一点说，要想改变一级指针，需要传递一级指针的地址，也就是二级指针。

void  GetMemory2(char **p, int num) {
    *p = (char *)malloc(sizeof(char) * num);
}

运行结果：运行正确
解释：GGtMemory(char **p,int num)中的函数参数是char **p类型的，而传入函数的str的类型是char *。利用二级指针修改一级指针，没有问题。

char *GetMemory3(int num) {
    char *p = (char *)malloc(sizeof(char) * num);
    return p;
}
运行结果：运行正确
解释：用函数返回值来传递动态内存的地址，没有问题。


char *GetMemory4() {
    char p[] = "hello  world";
    return p;  //编译器警告！返回局部变量
}
运行结果：运行无误，但打印乱码
解释：GetMemory4()中的p[]为函数内的局部自动变量，在函数返回后，内存已经被释放。如果一步步调试，会发现执行str=GetMenory4();后str不再是NULL了，但是str的内容并不是hello world，而是垃圾数据。


char *GetMemory5() {
    char *p = "hello  world!";
    return p;
}

运行结果：运行正确，但不合理
解释：GetMemory5()中的p指向的是字符串常量，字符串常量保存在静态存储区。虽然调用GetMemory5()运行不会出错，但是函数GetMemory5()的设计概念却是错误的。因为GetMemory5()内的“hello world”是常量字符串，位于静态存储区，它在程序生命期内恒定不变。无论什么时候调用GetMemory5()，它返回的始终是同一个“只读”的内存块。例如，如想执行 p[0]='n';则程序会中断，并提示内存错误。

void GetMemory6(char *&p) {
    p = (char *)malloc(sizeof(char) * 10);
}


int main() {
    char *str = NULL;

    GetMemory1(str, 100);   
　　 strcpy(str, "hello"); // X

    GetMemory2(&str, 100);  
    strcpy(str, "hello");  // OK

    str = GetMemory3(100); 
    strcpy(str, "hello"); // OK


    str = GetMemory4();  // X

    str = GetMemory5();  // OK

    GetMemory6(str);   
    strcpy(str, "hello"); // OK

    printf("%s", str);
    free(str);

    return 1;
}

如何把数字字符串转换为整型数据？

bool str2int(const char *str, int &result)
{
     int temp = 0;
     const char *ptr = str;          // ptr保存str字符串开头
     if (*str == '-'|| *str == '+')     // 若第一个字符为符号位
     {
         str++;   // 前移一位
     }
     //转换为数据
     while (*str != 0)
     {
         if ((*str < '0') || (*str > '9'))
         {
             return false;
         }
         temp = temp*10 + (*str - '0');
         str++;
     }
     //若为负数
     if (*ptr == '-')
     {
         temp = -temp;
     }

　　　result = temp;
     return  true;
 }

如何把整型数转成字符串

void int2str(int data, char *array) {
    bool bMinus = false;

    if (data < 0) {
        data = -data;
        bMinus = true;
    }
int i = 0;

    while (data > 0) {
        int digital = data % 10;
        array[i++] = '0' + digital ;
        data = data / 10;
    }

    array[i] = '\0';

    for (int j = 0; j < i / 2; j++) {
        char temp = array[j];
        array[j] = array[i - j - 1];
        array[i - j - 1] = temp;
    }

    if (bMinus) {
        for (int k = i; k > 0; k--) {
            array[k] = array[k - 1];
        }

        array[0] = '-';
        array[i + 1] = '\0';
    }
}

int main() {
    char arr[10];
    int2str(1357, arr);

    return 1;
}

如何把字符串中某个指定的字符删除？

void deleteChar1(char *str, char ch) {

    while ('\0' != *str) {
        if (ch == *str) {
            int i = 0;
            while ('\0' != *(str + i)) {
                *(str + i) = *(str + i + 1); //把后面的字符往前移一个位子
                i++;
            }
        }
        str++;
    }
}

char * DeleteChar2(char *str, char c)
{
     char *head = NULL;
     char *p = NULL;
     if (NULL == str)
         return NULL;
     head = p = str;   // 指向字符串头，准备遍历
     while (*p)
     {
         if (*p != c)
         {
             *str++ = *p++;
         }
         else
         {
             ++p;
         }
     }
     *str = '\0';
     return head;
 }

写一个函数查找两个字符串中的第一个公共字符串

bool findSameSub(const char *str1, const char *str2, char *pSubStr) {
    int iLen1 = strlen(str1);
    int iLen2 = strlen(str2);

    const char *pShortStr = str1;
    const char *pLongStr = str2;
    int iShortLen = iLen1;
    if (iLen1 > iLen2) {
        pShortStr = str2;
        pLongStr = str1;
        iShortLen = iLen2;
    }


    for (int iStart = 0; iStart < iShortLen; iStart++) {
        for (int iSubLen = iShortLen - iStart; iSubLen > 1; iSubLen --) {
            pSubStr = strncpy(pSubStr, pShortStr, iSubLen);
            pSubStr[iSubLen] = '\0';
            if (strstr(pLongStr, pSubStr) != NULL) {
                return true;
            }
        }
        pShortStr++;
    }

    return false;
}

int main() {

    const char *pStr1 = "abcdefghijklmnopqrstuvwxyz";
    const char *pStr2 = "dfifdlei2xkdja3opqldiai'akd'";

    char *pSubStr = (char *)malloc(strlen(pStr1) + 1);
    bool bOK = findSameSub(pStr1, pStr2, pSubStr);
    if (bOK) {
        printf("result3 = %s\n", pSubStr);
    } else {
        printf("can't find it");
    }

    free(pSubStr);
}