字符串操作与一级指针内存模型

最新推荐文章于 2021-12-02 15:56:01 发布
最新推荐文章于 2021-12-02 15:56:01 发布
阅读量311 收藏
点赞数
分类专栏： C++ 文章标签： 指针 内存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/saizo123/article/details/77140771
版权

字符串copy函数推演过程
最次的字符串拷贝代码

#define _CRT_SECURE_NO_WARNINGS


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

int main(void)
{
    char *src = "abcd";

    char buf[64];

    int i = 0;
    for (i = 0; *(src + i) != '\0'; i++)
    {
        buf[i] = *(src + i);
    }
    buf[i] = '\0';

    printf("buf:%s\n", buf);

    system("PAUSE");
    return 1;
}

第一种风格的拷贝函数

#define _CRT_SECURE_NO_WARNINGS


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

void str_cpy01(char *from,char *to)
{
    int i = 0;
    for (i = 0; *from  != '\0'; from++,to++)
    {
        *to = *from;
    }
    *to = '\0';
}

int main(void)
{
    char *src = "abcd";

    char buf[64];


    str_cpy01(src,buf);
    printf("buf:%s\n", buf);

    system("PAUSE");
    return 1;
}

第二种风格的copy函数

#define _CRT_SECURE_NO_WARNINGS


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


//*操作 和++的操作
//++ 优先级高 
void str_cpy02(char *from,char *to)
{
    int i = 0;
    for (i = 0; *from  != '\0';)
    {
        *to++ = *from++;
    }
    *to = '\0';
}

int main(void)
{
    char *src = "abcd";

    char buf[64];


    str_cpy02(src, buf);
    printf("buf:%s\n", buf);

    system("PAUSE");
    return 1;
}

第三种风格

#define _CRT_SECURE_NO_WARNINGS


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

void str_cpy03(char *from,char *to)
{
    while ((*to = *from) != '\0'){
        from++;
        to++;
    }
}

int main(void)
{
    char *src = "abcd";

    char buf[64];


    str_cpy03(src, buf);
    printf("buf:%s\n", buf);

    system("PAUSE");
    return 1;
}

第四种风格

#define _CRT_SECURE_NO_WARNINGS


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

void str_cpy04(char *from,char *to)
{
    while ((*to++ = *from++) != '\0');
}

int main(void)
{
    char *src = "abcd";

    char buf[64];


    str_cpy04(src, buf);
    printf("buf:%s\n", buf);

    system("PAUSE");
    return 1;
}

第五种风格

#define _CRT_SECURE_NO_WARNINGS


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

void str_cpy05(char *from,char *to)
{
    while ((*to++ = *from++));
}

int main(void)
{
    char *src = "abcd";

    char buf[64];


    str_cpy05(src, buf);
    printf("buf:%s\n", buf);

    system("PAUSE");
    return 1;
}

第六种风格：避免操作空指针以及引入辅助指针变量增强程序的健壮性

#define _CRT_SECURE_NO_WARNINGS


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


int str_cpy06(char *from, char *to)
{
    char * tmpfrom = from;//避免修改形参

    char * tmpto = to;

    if (from == NULL || to == NULL)//避免操作空指针
        return -1;

    while (*tmpto++ = *tmpfrom++);

    printf("from:%s\n",from);
    return 0;
}

int main(void)
{
    char *src = "abcd";

    char buf[64];


    str_cpy06(src, buf);
    printf("buf:%s\n", buf);

    system("PAUSE");
    return 1;
}

strstr模型
strstr–do-while模型

#define _CRT_SECURE_NO_WARNINGS


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


int getCountDoWhile(char * p_str, char *sub_str, int *ncount)
{
    int ret = 0;

    char * src = p_str;
    int tmp_count = 0;

    if (p_str == NULL || sub_str == NULL || ncount == NULL)//合法性检测
    {
        ret = -1;
        printf("%s is error:(p_str == NULL || sub_str == NULL || ncount == NULL)\n", __FUNCTION__);
        return  ret;
    }

    do{
        src = strstr(src, sub_str);
        if (src != NULL)
        {
            tmp_count++;
            src += strlen(sub_str);
        }
        else{
            break;
        }


    } while (*src != '\0');

    *ncount = tmp_count;

    return ret;
}

int main(void)
{
    //strstr(str, str2)
    int ncount = 0;
    int ret = 0;

    char *p = "11abcd111122abcd3333322abcd3333322qqq";
    ret = getCountDoWhile(p,"abcd",&ncount);

    if (ret != 0){
        printf("func getCountDoWhile() err:%d \n", ret);
        return ret;
    }

    printf("ncount:%d \n", ncount);
    system("PAUSE");
    return ret;
}

strstr–while模型

#define _CRT_SECURE_NO_WARNINGS


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

int getCountWhile(char * p_str, char *sub_str, int *ncount)
{
    int ret = 0;

    char * src = p_str;
    int tmp_count = 0;

    if (p_str == NULL || sub_str == NULL || ncount == NULL)//合法性检测
    {
        ret = -1;
        printf("%s is error:(p_str == NULL || sub_str == NULL || ncount == NULL)\n", __FUNCTION__);
        return  ret;
    }
    while (src = strstr(src,sub_str)){
        tmp_count++;
        src += strlen(sub_str);
        if (*src == '\0')
            break;
    }
    *ncount = tmp_count;
    return ret;
}

int main(void)
{
    //strstr(str, str2)
    int ncount = 0;
    int ret = 0;

    char *p = "11abcd111122abcd3333322abcd3333322qqq";
    ret = getCountWhile(p, "abcd", &ncount);

    if (ret != 0){
        printf("func getCountWhile() err:%d \n", ret);
        return ret;
    }

    printf("ncount:%d \n", ncount);
    system("PAUSE");
    return ret;
}

两头堵模型
求出字符串（首尾有空格）有效字符的长度

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include<ctype.h>
int getCount(char * src,int * count)
{
    int ret = 0;

    char *tmp_p = src;
    int tmp_count = 0;

    int head = 0,tail = 0;
    if(src == NULL || count == NULL)
    {
        ret = -1;
        printf("%s is error!(src == NULL || count == NULL)\n",__FUNCTION__);
        return ret;
    }

    while(*(tmp_p+head) != '\0' && isspace(tmp_p[head])){
        head++;
    }
    tail = strlen(src)-1;

    while(*(tmp_p+tail) != '\0' && isspace(tmp_p[tail])){
        tail--;
    }

    tmp_count = tail - head + 1;

    *count = tmp_count;


    return ret;
}

int main(void)
{
    char *p = "    abcdefg    ";
    int ret = 0;

    int ncount = 0;

    ret = getCount(p,&ncount);
    if(ret != 0){
        printf("getCount failed!ret : %d\n",ret);
        return ret;
    }
    printf("ncount:%d\n",ncount);

    printf("Hello World!\n");
    return 0;
}

去除字符串中的空格，输出新字符串
注意：向一个指针指向的内存空间拷贝数据的时候要留心是否可以向该片内存空间写入数据，常量数据区是不可以写入数据的。

int trimeSpace(char *src,char *new_str)
{
    int ret = 0;

    char *tmp_p = src;

    int head = 0,tail=0;

    if(src == NULL || new_str == NULL)
    {
        ret = -1;
        printf("%s is error!(src == NULL || count == NULL)\n",__FUNCTION__);
        return ret;
    }

    tail = strlen(src)-1;

    while(tmp_p[head] != '\0' && isspace(tmp_p[head])){
        head++;
    }

    while(tmp_p[tail] != '\0' && isspace(tmp_p[tail])){
        tail--;
    }

    strncpy(new_str,tmp_p+head,tail-head+1);
    new_str[tail-head+1] = '\0';

    return ret;
}

int main(void)
{
    char *p = "    abcdefg    ";
    char buf[1024];
    int ret = 0;



    ret = trimeSpace(p,buf);
    if(ret != 0){
        printf("getCount failed!ret : %d\n",ret);
        return ret;
    }
    printf("buf:%s\n",buf);

    printf("Hello World!\n");
    return 0;
}

注意：strncpy函数并不会在目标字符串后面自动添加’\0’

字符串反转模型
类似两头堵模型的字符串反转

int inverse(char *src_str)
{
    int ret = 0;
    int len = strlen(src_str);
    char * head = src_str;
    char * tail = src_str + (len-1);

    char tmp_c = 0;

    if(src_str == NULL){
        ret = -1;
        printf("%s is error!src_str == NULL\n",__FUNCTION__);
        return ret;
    }

    while(head < tail){
        tmp_c = *head;
        *head++ = *tail;
        *tail-- = tmp_c;
    }

    return ret;
}

int main(void)
{
    //char *p = "    abcdefg    ";//不能用字符串常量赋值给一个指针进行该实验，因为常量区不可修改数据
    char buf[1024]="abcdefg";
    int ret = 0;

    ret = inverse(buf);
    if(ret != 0){
        printf("inverse failed!ret : %d\n",ret);
        return ret;
    }
    printf("buf:%s\n",buf);

    printf("Hello World!\n");
    return 0;
}

利用堆栈的字符串反转（递归）
递归简单的逆序打印不存储结果

int inverse_02(char *src_str)
{
    int ret = 0;

    char *tmp_p = src_str;

    if(src_str == NULL){//合法性检测
        ret = -1;
        printf("%s is error!src_str == NULL\n",__FUNCTION__);
        return ret;
    }

    if(*tmp_p == '\0')//递归停止的正常条件
    {
        return 0;
    }

    inverse_02(tmp_p+1);//将tmp_p指向的内存空间的数据的地址逐个压栈

    printf("%c",*tmp_p);

    return ret;
}

int main(void)
{

    char buf[1024]="abcdefg";
    int ret = 0;

    printf("buf:");
    ret = inverse_02(buf);
    if(ret != 0){
        printf("inverse_02 failed!ret : %d\n",ret);
        return ret;
    }

    printf("\nHello World!\n");
    return 0;
}

递归结合全局变量

char g_buf[1024]={0};

int inverse_03(char *src_str)
{
    int ret = 0;

    char *tmp_p = src_str;

    if(src_str == NULL){//合法性检测
        ret = -1;
        printf("%s is error!src_str == NULL\n",__FUNCTION__);
        return ret;
    }

    if(*tmp_p == '\0')//递归停止的正常条件
    {
        return 0;
    }

    inverse_03(tmp_p+1);//将tmp_p指向的内存空间的数据的地址逐个压栈

    strncat(g_buf,tmp_p,1);

    return ret;
}

int main(void)
{

    char buf[1024]="abcdefg";
    int ret = 0;


    ret = inverse_03(buf);
    if(ret != 0){
        printf("inverse_03 failed!ret : %d\n",ret);
        return ret;
    }
    printf("g_buf:%s\n",g_buf);
    printf("\nHello World!\n");
    return 0;
}

递归结合局部变量（指针做函数参数）

int inverse_04(char *src_str,char *str_out)
{
    int ret = 0;

    char *tmp_p = src_str;

    if(src_str == NULL || str_out == NULL){//合法性检测
        ret = -1;
        printf("%s is error!(src_str == NULL || str_out == NULL)\n",__FUNCTION__);
        return ret;
    }

    if(*tmp_p == '\0')//递归停止的正常条件
    {
        return 0;
    }

    inverse_04(tmp_p+1,str_out);//将tmp_p指向的内存空间的数据的地址逐个压栈

    strncat(str_out,tmp_p,1);

    return ret;
}

int main(void)
{

    char buf[1024]="abcdefg";
    char res[1024];

    int ret = 0;

    memset(res,0,sizeof(res));


    ret = inverse_04(buf,res);
    if(ret != 0){
        printf("inverse_04 failed!ret : %d\n",ret);
        return ret;
    }
    printf("res:%s\n",res);
    printf("\nHello World!\n");
    return 0;
}

两个小练习
有一个字符串”1a2b3d4z”,；
要求写一个函数实现如下功能，
功能1：把偶数位字符挑选出来，组成一个字符串1。valude；20分
功能2：把奇数位字符挑选出来，组成一个字符串2，valude 20
功能3：把字符串1和字符串2，通过函数参数，传送给main，并打印。
功能4：主函数能测试通过。
int getStr1Str2(char *souce, char *buf1, char *buf2);

int getStr1Str2(char *souce, char *buf1, char *buf2)
{
    int ret = 0;
    char *src = souce;
    if(souce == NULL || buf1 == NULL || buf2 ==NULL){
        ret = -1;
        printf("%s is error!(source == NULL || buf1 == NULL || buf2 ==NULL)\n",__FUNCTION__);
        return ret;
    }

    while(*src != '\0'){

        *buf1 = *src;
        src++;
        buf1++;

        *buf2 = *src;
        src++;
        buf2++;
    }


    return ret;
}
int main(void)
{

    char src[1024]="1a2b3c4d";
    char buf1[512]={0};
    char buf2[512]={0};

    int ret = 0;
    ret = getStr1Str2(src,buf1,buf2);
    if(ret != 0){
        printf("getStr1Str2 failed!ret : %d\n",ret);
        return ret;
    }
    printf("src:%s\n",src);
    printf("偶数位的数据buf2:%s\n",buf2);
    printf("奇数位的数据buf1:%s\n",buf1);
    printf("\nHello World!\n");
    return 0;
}

键值对（”key = valude”）字符串，在开发中经常使用；
要求1：请自己定义一个接口，实现根据key获取valude；40分
要求2：编写测试用例。30分
要求3：键值对中间可能有n多空格，请去除空格30分
注意：键值对字符串格式可能如下：
“key1 = valude1”
“key2 = valude2”
“key3 = valude3”
“key4 = valude4”
“key5 = “
“key6 =“
“key7 = “
int getKeyByValude(char *keyvaluebuf, char *keybuf, char *valuebuf);

int trimeSpace(char *src,char *new_str)
{
    int ret = 0;

    char *tmp_p = src;

    int head = 0,tail=0;

    if(src == NULL || new_str == NULL)
    {
        ret = -1;
        printf("%s is error!(src == NULL || count == NULL)\n",__FUNCTION__);
        return ret;
    }

    tail = strlen(src)-1;

    while(tmp_p[head] != '\0' && isspace(tmp_p[head])){
        head++;
    }

    while(tmp_p[tail] != '\0' && isspace(tmp_p[tail])){
        tail--;
    }

    strncpy(new_str,tmp_p+head,tail-head+1);
    new_str[tail-head+1] = '\0';

    return ret;
}

int getKeyByValude(char *keyvaluebuf,  char *keybuf,  char *valuebuf)
{
    int ret = 0;

    char * p = keyvaluebuf;//辅助指针变量初始化

    if(keyvaluebuf == NULL || keybuf == NULL || valuebuf ==NULL){
        ret = -1;
         printf("%s is error!(keyvaluebuf == NULL || keybuf == NULL || valuebuf ==NULL)\n",__FUNCTION__);
        return ret;
    }
    //1. 从母串中查找子串
    p = strstr(p,keybuf);
    if(p == NULL){
        ret = -1;
        return ret;
    }

    p += strlen(keybuf);//辅助指针变量再次初始化使得下一次可用


    //2. 判断有没有等号
    p = strstr(p,"=");
    if(p == NULL){
        ret = -1;
        return ret;
    }

    p += strlen("=");//辅助指针变量再次初始化使得下一次可用，指向等号后面开始的地方

    //3. 去除等号后面的空格
    ret = trimeSpace(p,valuebuf);//调用自己封装的函数
    if(ret != 0){
        printf("getKeyByValude failed \n");
        return ret;
    }

    return ret;

}

int main(void)
{

   char *keyandvalue = "key2 =         value2   ";
   char *key = "key2";

   char res_str[1024]={0};

    int ret = 0;
    ret = getKeyByValude(keyandvalue,key,res_str);
    if(ret != 0){
        printf("getKeyByValude failed!ret : %d\n",ret);
        return ret;
    }
    printf("res_str:%s\n",res_str);

    printf("\nHello World!\n");
    return 0;
}

一级指针易错模型分析
字符串作函数参数的时候，记得在被调函数进行合法性检测
对指针变量进行合法性检测主要是检测指针本身的值而不是检测指针变量指向的内存空间的值
比如下面代码就有错误：

void copy_str21(char *from, char *to)
{

    if (*NULL = '\0' || *to!=’\0’) //错误判断
    {
        Printf(“func copy_str21() err\n”);
        return; 
    }


    for (; *from!='\0'; from++, to++)
    {
        *to = *from;
    }
    *to = '\0';
}

字符串初始化字符数组因为忽略C风格的字符串默认结尾有个’\0’作为结尾符号而发生越界，如：

char buf[3] = "abc";

不断修改指针变量的值会导致指针指向的内存区域发生变化，从而在涉及到free的时候，释放错误的内存块导致程序崩溃，如：
这里写图片描述
试图将被调函数里分配的内存空间向外传递，但如果被调函数实在栈空间分配的内存则传递是不可能成功的，这点需要格外注意

从主调函数传递一个实参的地址给被调函数，被调函数制图修改该实参的值，需要注意先使用间接访问操作符取出相应地址处的内存数据，再进行修改操作，这里主要是由于*和++操作符的优先级不一样导致的。
mycount++;和(mycount)++;
关于const

int main()
{
const int a; 
int const b; 

const char *c;
char * const d; char buf[100]
const char * const  e ;
return 0;
}

第一个第二个意思一样 代表一个常整形数
第三个 c是一个指向常整形数的指针(所指向的内存数据不能被修改，但是本身可以修改)
第四个 d 常指针（指针变量不能被修改，但是它所指向内存空间可以被修改）
第五个 e一个指向常整形的常指针（指针和它所指向的内存空间，均不能被修改）

合理的利用const可以带来的好处：

指针做函数参数，可以有效的提高代码可读性，减少bug；
清楚的分清参数的输入和输出特性；

结论：

指针变量和它所指向的内存空间变量，是两个不同的概念。。。。。。
看const 是放在*的左边还是右边 放在右边修饰指针变量，放在左边修饰所指向的内存变量；
C语言中的const是个冒牌货，通过指针可以绕过他的只读属性；

秋刀鱼之味
关注
专栏目录
字符串和一级指针
小白杨的博客
04-08 147
1 字符串的基本操作 1.1字符数组初始化方法 在C语言中使用字符数组来模拟字符串 C语言中的字符串是以’\0’结束的字符数组 C语言中的字符串可以分配于栈空间，堆空间或者只读存储区 int main() { //1 用字符串来初始化数组 char buf2[] = {'a', 'b','c','d','\0'}; //2 字符串常量初始化一个字符数组 ...
【C 语言】字符串 一级指针 内存模型 ( 指定大小字符数组 | 未指定大小字符数组 | 指向常量字符串的指针 | 指向堆内存的指针 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
11-22 1153
一、字符串 一级指针 内存模型、 1、指定大小字符数组、 2、未指定大小字符数组、 3、指向常量字符串的指针、 4、指向堆内存的指针、
03字符串操作和一级指针内存模型
lzjsqn的专栏
03-12 1077
字符串操作和一级指针内存模型字符串操作和一级指针内存模型 字符串的基本操作 1 关于字符串不得不说的话 2 字符数组初始化 3 用字符串初始化字符数组 4 通过数组下标和指针访问字符串内容 一级指针内存模型 字符串copy函数推演过程 strstr模型 两头堵模型 字符串反转模型 两个小练习 一级指针易错模型分析 关于const 1. 字符串的基本操作1.1 关于字符串不得不说的话 C语言的字符串是
C——提高（2）字符串一级指针、二级指针内存模型
wuseyukui的专栏
12-16 2528
字符串一级指针C语言里没有实质的字符串类型，通过字符数组来模拟。 C语言的字符串是以0结尾的字符串。 C语言字符串的内存分配 可以分配在堆上、栈上、全局区上。1、字符串一级指针内存模型buf数组与指针的区别：注意： char buf[20] = “aaaa”; 字符串数组的初始化步骤是，先在常量区创建字符常量“aaaa”，再从字符常量区拷贝字符到堆区（临时区）。2、字符串copy函数的经典实现
【C 语言】二级指针 内存模型图 ( 指针数组 | 二维数组 | 自定义二级指针内存 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
11-28 1512
前言、 一、指针数组、 二、二维数组、 三、自定义二维指针内存、
【C 语言】一级指针 易犯错误 模型 ( 判定指针合法性 | 数组越界 | 不断修改指针变量值 | 函数中将栈内存数组返回 | 函数间接赋值形参操作 | 指针取值与自增操作 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
11-25 1292
一、判定指针合法性、 二、数组越界、 三、不断修改指针变量值、 四、函数中将栈内存数组返回、 五、函数间接赋值形参操作、 六、指针取值与自增操作、
指向指针数组的指针与存储字符串的指针数组
靡不有初，鲜克有终。
02-12 1305
今天看到一道题目，突然把自己对指针的理解整混乱了。 题目是这样的：假设定义了一个指针数组tBooks如下，请定义一个指向它的数组指针p,让程序可以顺利执行，并按要求打印出数据。 关键代码： char *tBooks[] = { "《数据结构》", "《计算机组成原理》", "《C语言程序设计》", "《计算机网络》"...
C语言中的二级指针的三种内存模型
修炼之路
04-04 1507
C语言中的指针用的是比较多，一级指针和二级指针时最常见的。其中，在C语言中二级指针相对于一级指针要难一些，下面就介绍一下C语言中二级指针的三种内存模型。 一、二维数组char a[5][5]内存模型 #include #include #include /* C语言中的二级指针的三种内存模型 */ //第一种模型，二维数组char a[5][5] void func1(){ //二维数组,表
【C 语言】二级指针内存模型 ( 指针数组 | 二维数组 | 自定义二级指针 | 将 一、二 模型数据拷贝到 三 模型中 并 排序 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
12-02 907
一、指针数组 和 二维数组 数据 拷贝到 自定义二级指针 中、 1、函数形参 设计规则、 2、三种内存模型 对应 函数形参 指针退化规则、 二、完整代码示例
详解C语言-二级指针三种内存模型
08-19
在这个模型中，arr是一个二级指针，指向一个指针数组，每个元素都是一个指针，指向一个字符串。为了使用这个数组，我们需要定义一个中间量，例如`char *tmp = NULL;`，然后我们可以使用这个中间量来操作数组的元素。...
C语言字符串相关一级指针内存模型
希望我的博客，能帮上你解决学习中工作中所遇到的问题
10-30 297
先看一个实例 void main() { char buf[20]= “aaaa”; char buf2[] = “bbbb”; char *p1 = “111111”; char *p2 = malloc(100); strcpy(p2, “3333”); system(“pause”); return ; }
C语言二级指针内存模型详解及示例
本文档深入解析了C语言中的二级指针及其三种不同的内存模型，旨在帮助读者更好地理解和运用这一高级概念。首先，让我们逐一介绍这三种内存模型： 1. **数组指针模型（char* arr[]）** 在这种模型中，定义了一个...
C语言解析：二级指针的三种内存模型深度剖析
以下是三种不同的二级指针内存模型的详细说明： 1. 第一种内存模型：`char *arr[]` 在这种模型中，`arr` 是一个指针数组，每个元素都是一个指向字符串字面量的指针。例如： ```c char *arr[] = {"abc", "def", ...
curl/types.h: No such file or directory问题的解决
saizo123的博客
06-27 3155
先看这篇https://blog.csdn.net/cwll2009/article/details/7894624 我直接把这个头文件注释掉了。
面试题
saizo123的博客
03-18 3046
**1、**64位的Linux编译后的程序只能在64位linux下运行，32位linux编译后的程序只能在32位的linux运行；64位的windows编译后的程序只能在64位windows下运行，32位windows编译后的程序可以在64位的windows运行。 2、数据类型字节大小 32位操作系统： char :1个字节(固定) (即指针变量): 4个字节(32位机的寻址空间是4个字节
一个openssl安装包下载网站
saizo123的博客
03-22 2737
https://slproweb.com/products/Win32OpenSSL.html
CentOS 7下安装boost
saizo123的博客
06-26 2329
我没有编译源码安装 直接 yum install boost yum install boost-devel yum install boost-doc 然后是测试程序 #include <boost/thread/thread.hpp> #include <iostream> #include <cstdlib> using namespace std; ...
error LINK2005: XXXX已经在 .obj 中定义"
saizo123的博客
08-13 1764
当项目代码比较多，文件也比较多的时候，这个问题真的非常棘手，可能会耗费大量的时间来排查错误。 问题出现的原因：在.h文件中定义了变量。然后A.cpp包含了该.h，B.cpp包含了该.h，于是在链接的时候，生成A.obj，B.obj，但是 .h中定义的变量会在这两个obj中又被定义，所以，导致了这个LINK2005错误。 解决方法：不要在.h中定义变量！！在.h中只声明函数，类。把具体的实现都必...
指针总结
saizo123的博客
03-18 841
1、指针的长度：在32位系统下是4位，在64位系统下是8位； 2、几种指针特殊的定义方式： 1、 int *const p; 指针常量：指针本身是常量，它指向的地址不可修改，也就是不能再指向别的地方了，但是可以修改它所指向的地址里的内容。 举例： int a = 10; int b = 20; int *const p = &a; p = &b; //错误 *p = 100;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值