C++博客-circle on -文章分类-c raise

007 string model in project

silvercell — Fri, 14 Jul 2017 07:46:00 GMT

摘要: 项目开发中字符串模型建立strstr的while dowhile模型//int cltClient_rev(void *handle, unsigned char *buf, int *buflen)//不要相信别人给你传送的内存地址是可用的int getCout(char *str, char *substr, int *count){ ... 阅读全文

silvercell 2017-07-14 15:46 发表评论

006 string and pointer

silvercell — Thu, 13 Jul 2017 04:58:00 GMT

the basic operate
一级指针的典型用法 : 数组、 字符串

在C语言中使用字符数组来模拟字符串

C语言中的字符串是以’\0’结束的字符数组

C语言中的字符串可以分配于栈空间，堆空间或者只读存储区

字符和字符数组:

int main(int argc, char * * argv)
{
    char buf[120]= "hello";
    printf("%s", buf);

    char buf2[120] = {'h','e','l','l','o'};
    printf("%s" , buf2);

    char buf3[] = "world";
    printf("%d , %d" , strlen(buf3) , sizeof(buf3));
    return 0;
}

数组或指针操作字符串：

int main()
{
    char buf[10] = "hello";
    for(int i = 0; i    {
        printf("%c" , buf[i]);
    }

    printf("\n");
    char * p = buf; //指向 buf[0]的地址不是数组！！！
    for(int i = 0; i    {
        printf("%c", *(p+i));
    }

    return 0;
//    hello
//    hello
}

buf[i] --> buf[0+i] --> *(buf+i)

中括号的本质:
buf5[10];
buf5 = buf5 + 1
buf5 是一个常量指针。编译器这么做的。

为什么这么做？
如果进行栈的内存回收，如果允许常量指针buf5 修改地址则很难在修改之后找到buf 的地址对这段内存进行析构。
为可保证数组这块内存首地址的安全 buf5 是一个常量，传到函数中也是常量指针地址不能轻易改变。
这就是为什么指针 p = p+1; 可以； buf5 = buf5 +1;不可以；

字符串一级指针的内存模型图

int main()
{
    char buf[20] = "aaaaa";
    char buf2[] = "11111";

    char * p1 = "mmmmm";

    char * p2 = malloc(100);
    strcpy(p2,"222222");
    free(p2);

    return 0;
}

-----

字符串做函数参数

业务模型和测试案例分开：

void cpstr(char * p , char * q)
{
    for(; *p != '\0'; p++, q++  )
    {
        *q = *p;
// *q++ = *q++; 先  *q = *p; 再 p++, q++
}
    *q = '\0';
}
/* 改进不用手动添加 \0
while( (*q = *p) !=0)
{
p++;
q++;
}
*/

/*
while( (*q++ = *p++) !=0)
{
;
}
*/

/*
while( (*q++ = *p++))
{
  ;
}
*/

int main()
{
    char * p = "helloworld";
    char dest[100];
    cpstr(p , dest);

    printf("dest: %s" , dest);
    return 0;
}

业务模型和测试案例未分开：

int main004()
{
    char from[] = "helloworld";
    char to[20];

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

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

改进代码

void cpstr(char * p , char * q)
{

//在形参中另存一份辅助变量不要轻易改变形参的值
char * p = tmp_p;
char * q = tmp_q;
//所以不会影响主调用函数指针的指向。

    for(; *p != '\0'; p++, q++  )
    {
        *q = *p;
//      *q++ = *q++;   先  *q = *p;  再 p++, q++
    }
    *q = '\0';
}
/* 改进不用手动添加  \0
   while( (*q = *p) !=0)
   {
      p++;
      q++;
   }
*/

/*

if( p ==NULL || q= NULL)
{
return -1;
} //添加判断

// -> while( (*q++ = *p++) !=0)；

   while( (*q++ = *p++) !=0)
   {
      ;
   }
*/

/*
   while( (*q++ = *p++))
   {
      ;
   }
*/

int main()
{
    char * p = "helloworld";
    char dest[100];
    cpstr(p , dest);

    printf("dest: %s" , dest);
    return 0;
}

项目开发中的字符串模型

strstr _ while do_while

silvercell 2017-07-13 12:58 发表评论

005 the pointer use for indirect assignment

silvercell — Wed, 12 Jul 2017 10:18:00 GMT

malloc 和 free 错误:

int main()
{
    char * p =NULL;
    p = (char * )malloc(100);

    strcpy(p , "hello"); "hello" 实际上是一个地址将这个地址的内容复制到p 直到 \0 结束
    printf("%s" , p);

    if( p != NULL)
    {
        free(p);
//        p = NULL; 解决方法
    }
//此时 p 是个野指针，指向一块垃圾数据
    if( p!= NULL)
    {
        free(p);
    }

    return 0;
}

释放指针所指的空间，但是指针的值没有重置为NULL
造成释放通过 if(p != NULL) 判断不出来，所以 free() 时候要进行指针重置为 NULL

indirect assignment use pointer

void changevar(int * p )
{
    *p = 20;
//通过函数将运算结果甩出来！！！
   // **** 很方便的返回多个结果很强大 *****
}

int main()
{
    int a = 1;
    int * p = &a;

    *p = 10;
    printf("%d" , a);
//    ---------
    changevar(&a);
//  ---------
    printf("%d" , a);
}

通过指针做函数参数的方法间接赋值改变运算结果

形参的提醒:

void changevar(int * p )
{ //参数表中的参数和函数体的参数本质上是一样的
// 参数表的参数多了个对外属性
*p = 20;
}

字面量的提示:

使用二级指针修改一级指针的地址:

void getMem(char ** p)
{
    *p = 200;
    //用二级指针间接修改一级指针的指向地址
}

int main()
{
    char * p = NULL;
    char ** q = NULL;

    p =100;
        printf("p: %d \n" , p);
    q= &p;
    getMem(q);

    printf("p: %d" , p);
    return 0;

    //p: 100
    //p: 200
}

关键就是内存和函数调用的模型图；

为什么用一级指针无法改变以及指针的指向，堆栈调用图很快就能理解！！！

void getMem2(char * p)
{
    p = 400;
    //用二级指针间接修改一级指针的指向地址
}

int main()
{
    char * p = NULL;
    char * q = (char *)malloc(100);

    p =100;
    printf("p: %d \n" , p);
    *q= &p;
    getMem2(q);

    printf("p: %d" , p);
    return 0;

    //p: 100
    //p: 100
}

指针使用的精髓:
不同函数同时操作一块内存空间时，通过内存首地址将内存传过去。运算结果在不同函数中并将其甩出来给主函数。
将计算过程在不同的函数中进行分解。

void getMem(char ** myp1, int * len1 )
{
    char * tmp1 = (char * )malloc(100);
    strcpy(tmp1 , "helloworld");
    *len1 = strlen(tmp1);
    *myp1 = tmp1;

    printf("in func getMem:\n");
    printf("tmp1: %s\n" , tmp1);
    printf("tmp1: %d\n" , tmp1);
    printf("len1: %d\n" , *len1);
}

int main(int argc, char * * argv)
{
    char * p1 = NULL;
    int  len1 = 0;

    getMem(&p1, &len1);

    printf("in main()\n ");
    printf("p1: %s\n" , p1);
    printf("p1: %d\n" , p1);
    printf("len: %d\n" , len1);


    return 0;
}

/*

in func getMem:

tmp1: helloworld

tmp1: 136160

len1: 10

in main()

p1: helloworld

p1: 136160

len: 10

指针做函数参数的典型应用场景：

main 函数为了完成某个任务，写很多子函数。通过指针做函数参数实现 main 和子业务的分层。模块划分的初步。
分层、模块、接口封装和设计、软件的功能之间的划分、软件信息系统

在一个函数中进行简介赋值：

int main()
{
    char from[120];
    char to[120];

    char * p1 = NULL;
    p1 = from;

    char * p2 = NULL;
    p2 = to;


    strcpy(p1, "helloworld");

    while( *p1 != '\0')
    {
        *p2++ = *p1++;
    }
    *p2 = '\0';//并没有将 '\0'拷进去直接打印会发生错误

    printf("to: %s" , to);

    return 0;
}

指针间接赋值的推论:
使用n级指针，更改 n-1 级指针的值。

指针的半壁江山 10 铁律。
另外？函数参数回调函数

指针作函数参数的输入和输出特性:

主调函数提前分配内存将内存传给被调用函数叫指针的输入
被调函数分配内存将结果输出供给主调函数使用

学习思路:
没有内存哪有指针，指针是指向内存地址编号的变量。类型是变量的类型。
指针的关键在内存的分析。内存是如何分配的！！！

铁律4：应用指针必须和函数调用相结合（指针做函数参数）

编号	指针函数参数内存分配方式（级别+堆栈）		主调函数实参	被调函数形参				备注
01	1级指针（做输入）	堆	分配	使用				一般应用禁用
		栈	分配	使用				常用
		Int showbuf(char p); int showArray(int array, int iNum)
02	1级指针（做输出）	栈	使用	结果传出				常用
		int geLen(char pFileName, int pfileLen);
03	2级指针（做输入）	堆	分配	使用				一般应用禁用
		栈	分配	使用				常用
		int main(int arc ,char *arg[]); 指针数组 int shouMatrix(int [3][4], int iLine);二维字符串数组
04	2级指针（做输出）	堆	使用	分配		常用，但不建议用，转化成02
		int getData(char *data, int dataLen); Int getData_Free(void data); Int getData_Free(void *data); //避免野指针
05	3级指针（做输出）	堆	使用		分配		不常用
		int getFileAllLine(char **content, int pLine); int getFileAllLine_Free(char **content, int pLine);

指针做函数参数，问题的实质不是指针，而是看内存块，内存块是1维、2维。

1）如果基础类int变量，不需要用指针；

2）若内存块是1维、2维。

silvercell 2017-07-12 18:18 发表评论

004 pointer laws 1、2、3

silvercell — Wed, 12 Jul 2017 09:49:00 GMT

指针铁律专题

铁律1：指针是一种数据类型  

1） 指针也是一种变量，占有内存空间，用来保存内存地址

测试指针变量占有内存空间大小

2）*p操作内存

在指针声明时，*号表示所声明的变量为指针

在指针使用时，*号表示 操作 指针所指向的内存空间中的值

*p相当于通过地址(p变量的值)找到一块内存；然后操作内存

*p放在等号的左边赋值（给内存赋值）

*p放在等号的右边取值（从内存获取值）

3）指针变量和它指向的内存块是两个不同的概念

//含义1 给p赋值p=0x1111; 只会改变指针变量值，不会改变所指的内容；p = p +1; //p++

//含义2 给*p赋值*p='a'; 不会改变指针变量的值，只会改变所指的内存块的值  

//含义3 =左边*p 表示 给内存赋值， =右边*p 表示取值 含义不同切结！

//含义4 =左边char *p

//含义5 保证所指的内存块能修改

4）指针是一种数据类型，是指它指向的内存空间的数据类型

含义1：指针步长（p++），根据所致内存空间的数据类型来确定

p++=è(unsigned char )p+sizeof(a);

结论：指针的步长，根据所指内存空间类型来定。

铁律2：通过*p/*p++ 来改变变量的值是指针存在的最大意义

1）两码事：指针变量和它指向的内存块变量

2）条件反射：指针指向某个变量，就是把某个变量地址否给指针

3）*p间接赋值成立条件：3个条件

a)2个变量（通常一个实参，一个形参）

b) 建立关系，实参取地址赋给形参指针

c) *p形参去间接修改实参的值

Int iNum = 0; //实参
int *p = NULL;
p = &iNum;
iNum = 1;
*p =2 ; //通过*形参 == 间接地改变实参的值
*p成立的三个条件：

4）引申： 函数调用时,用n指针（形参）改变n-1指针（实参）的值。

//改变0级指针（int iNum = 1）的值有2种方式

//改变1级指针（eg char *p = 0x1111 ）的值，有2种方式

//改变2级指针的（eg char **pp1 = 0x1111 ）的值，有2种方式

//函数调用时，形参传给实参，用实参取地址，传给形参，在被调用函数里面用*p，来改变实参，把运算结果传出来。

//指针作为函数参数的精髓。

间接赋值的应用场景分析

//C++多态实现的技术推演
//AOP切面编程（java 2-3），3
//1定义一个变量（通常是实参）定义一个变量（通常是形参）
//2建立联系把实参取地址取地址传给形参
//3*p形参，就间接地修改了是实参的值。

//*p = 10;

//间接赋值应用场景概念建立
//1 在一个函数里面
//*p1++ = *p2++ //完成内存块的copy
//2 在两个函数之间，指针做函数参数把运算结果给甩出来
//123
//12 3
//1 23

间接赋值的推论=====è指针做函数参数

//在函数调用的时候
//用1级指针（形参）去改变了0级指针（实参）的值（通过*p去间接修改了实参的在值）

//用2级指针（形参）去改变了1级指针（实参）的值（通过*p去间接修改了实参的在值）
//用3级指针（形参）去改变了2级指针（实参）的值（通过*p去间接修改了实参的在值）
//用n级指针（形参）去改变了n-1级指针（实参）的值（通过*p去间接修改了实参的在值）

形象的比如:

子弹沿着枪管发射，才有威力！

指针就像子弹,函数就像枪管，指针沿着枪管发射出去，才能显示它的威力。。。。。。
我们的研究方向。。。。。。（你明白了?）

铁律3：理解指针必须和内存四区概念相结合

1）主调函数被调函数

a) 主调函数可把堆区、栈区、全局数据内存地址传给被调用函数

b) 被调用函数只能返回堆区、全局数据

2）内存分配方式

a) 指针做函数参数，是有输入和输出特性的。

silvercell 2017-07-12 17:49 发表评论

003 memory div 4 model and call function model

silvercell — Tue, 11 Jul 2017 04:21:00 GMT

why learn ?

the variable 's lifetime
the stream to call the func

how c program run

os load the program into the memory
c language div the memory to 4 piece (heap stack global codes)
find the door main() and execute

global division
全局区的理解:

#include
#include
#include    <string.h>

char * getstr1()
{
    char * p = "hello";
    return p;
}
char * getstr2()
{
    char * q = "hello";
    return q;
}

int main(int argc, char * * argv)
{
    char * a = NULL;
a = getstr1();
    char * b = NULL;
b = getstr2();

    printf("%#p:%s, %#p:%s", a,a,b,b);
    return 0;
}

-----

----

编译器优化代码一个字符串常量在常量区存在相同的则会指向相同的地址相同的值

堆、栈区的理解

画图分析为什么这样传参数不对？？？：

char * getstr()
{
    char buf[20];
    strcpy(buf,"hello");
    return buf;
}

int main()
{
    char * p = getstr();
    printf("%s" , p);
    return 0;
}

指针是基于内存 存储的是内存的地址编号。
对内存的深刻学习，知道内存是在哪分配的。

栈的开口方向

int main()
{
    int a = 10;
    int b = 3;
    printf("%#p\n%#p" , &a , &b);
    return 0;
}

0X000000000062FE4C

0X000000000062FE48

buf[20] 的内存增长方向

int main()
{
    char buf[20];
    printf("\n%#p \n%#p \n%#p" , &buf[0] , &buf[1] , &buf[2]);
    return 0;
}

栈是静态编译；编译器编译期间，扫描代码期间已经确定下 buf 所代表的内存空间标号。

函数的执行过程

函数调用
----

----
内存的使用范围:

main() 函数可以在堆栈和全局区上分配内存 fa() fb() 可以使用因为 mian() 函数执行没有结束。

在 fa() fb() 中申请的内存 main() 不一定可以使用。
fa（） fb() 在栈上分配则函数结束后消失。
fb() 中全局区的常量字符串可以被 main() fa() 使用
----

一个 main() 函数执行多次调用函数
c/c++ 编译器只创建一个内存四区

返回地址是在函数调用其它函数时候记录函数执行到哪一行，当其他函数执行之后，继续从这一行开始向下执行函数。

指针是数据类型:
*p 进行定位内存空间：可以进行读写
----
常量区不能被修改

char * getstr()
{
    char *p = NULL;
    p = "admin";
    return p;
}

int main()
{
    char * p = getstr();
    printf("%s" , p);
    *(p+2) = 'M';  //挂了
    printf("%s" , p);
    return 0;
}

指针也是一种数据类型

指针做函数参数:

int getA1(char * p1);
int getA2(char **p2);
int getA3(char ***p3);
int getA4(char (*p4)[30]);
int getA5(char p5[10][30]);

在编译器上，都只会分配一个指针类型变量的空间 4B（sys32 platform）
使用的时候根据业务逻辑来真正当作一维二维三维指针

指针是一种数据类型，是指它指向的内存空间的数据类型

含义1：指针步长（p++），根据所致内存空间的数据类型来确定

p++=è(unsigned char )p+sizeof(a);

结论：指针的步长，根据所指内存空间类型来定

silvercell 2017-07-11 12:21 发表评论

002 before memory div 4 the essence of datatype and variable

silvercell — Tue, 11 Jul 2017 04:15:00 GMT

数据类型的本质
固定大小内存块的别名

different type of data

int main(int argc, char * * argv)
{
    int b[10];
    printf("b: %d , b+1: %d , &b: %d , &b+1: %d" ,b, b+1 ,&b , &b+1);
//    b: 6487584 , b+1: 6487588 , &b: 6487584 , &b+1: 6487624
    return 0;
}

calculate the sizeof data

sizeof

typedef define data simple and complex

typedef struct Teacher{
char name[100];
char project[20];
}tec;

typedef int sys32int;

package the data

int socketclient_init(void ** handle)

【memcpy & memset】
void * memcpy(void * dest , const void * src , size_t len);
void * memset(void * buf , int c , size_t num);

the void use

void * p = NULL;
p = (char *)malloc(100);

malloc 返回类型 void *
char *p = (char *)malloc(100);

变量的本质
连续的内存空间的别名。门牌号。

内存有地址编号，拿到地址编号也可以修改内存。

1 int main()
2 {
3     int a = 12;
4     printf("%d : " , &a);
5     printf("%d\n" , a);
6     //  &a : 6487628
7
8     *((int *)6487628 ) = 10;
// *((int *)&a ) = 10;
9     printf("%d : " , &a);
10     printf("%d" , a);
11
12     //6487628 : 12
13     //6487628 : 10
14 }

变量：名称大小作用域

变量的生命周期？
-> 内存四区模型，函数调用模型

silvercell 2017-07-11 12:15 发表评论

001 c basic and knowledgetables

silvercell — Tue, 11 Jul 2017 02:58:00 GMT

数据结构:

链表
队列栈
树二叉树
...

dev in diff platform

win_c
inux_c

think mode

API 抽象
模块化编程
拆分断层思维

protocol:

BS: http https
CS: tcp / udp ip

client / server API

      application (A)
      _________ / server
      socket (B)

A -> B -> B实现通信功能

      快速的实现: API 的使用查找实现

一级二级指针
void ** p 无类型的封装
数组作为函数参数和指针的关系: 等同，原因: 直接操作内存，提高效率
函数形参在函数参数表中和函数体中的类型等价

silvercell 2017-07-11 10:58 发表评论