接收端源代码新葡京32450网址,下面享有资源的基本单位

发布时间:2020-01-27  栏目:新葡京32450网址  评论:0 Comments

system函数功能非常苍劲
#include <process.h>
#include <stdio.h>

   
所谓进程等待,其实很简短。前边我们说过能够用fork创设子进度,那么这里我们就可以动用wait函数让父进度等待子进度运维截至后才初叶运转。注意,为了验证父进度确实是等待子进度运营停止后才持续运营的,大家选用了sleep函数。不过,在Linux上面,sleep函数的参数是秒,而windows上面sleep的函数参数是纳秒。

 

int b = isalpha(a);

     
由发送端和选拔端组成,这里只是完结了发送端发送接受端选取,约等于半双工吧。编写翻译,运转,发送端输入的数额将会在选取端展现出来,当在发送端输入end之后,发送端和选用端都会脱离程序。能够应用ipcs
-q命令查看系统中的复信号量的图景

误报病毒

    5、应用层
    4、传输层
    3、网络层
    2、数据链路层
    1、物理层

当 ptrace( PTRACE_ATTACH,
…卡塔尔国在被调用的时候传出了子进程的pid时, 它大概是与ptrace(PTRACE_TRACEME,
…卡塔尔(قطر‎的行事等同的,它会向子进程发送SIGSTOP时限信号,于是大家得以观测和改革子进度,然后利用 ptrace( PTRACE_DETACH,
…State of Qatar来使子进度继续运转下去。

 

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/types.h>
#include <sys/msg.h>
#define MAX_TEXT 512

void main( void )
{
    system( “type ss.cpp” ); // 显示ss.cpp的内容
    printf(“d\n”);
}
地点的代码在vc下能正常的编写翻译运维
只是使用
#include <process.h>
void main( void )
{
    system( “type ss.cpp” ); // 显示ss.cpp的内容
}
您却会发觉卡Bath基把这一个顺序生成的ss.exe文件便是木马程序,有一点点过分哦,误报了

 

让大家来看叁个例证,演示这一个追踪程序的进度

  1. #include <Windows.h>

  2. #include <iostream>

  3. #include<ctype.h>

  4. #include <stdlib.h>

  5. #include<stdio.h>

  6. #include <string.h>

  7. using
    namespace std;

  8.  

  9. long
    atox(char *s)

  10. {

  11.    while(isspace(*s卡塔尔State of Qatar//干掉开首的空格,只要有一个非零的数即跳出

int main()
{
 int msgid;
 unsigned char running=1;
 char buff[MAX_TEXT];
 MSG_REC  recivemsg;
 printf(“receive msg process is starting!\n”);
 printf(“the process id=%d\n”,getpid());
 msgid=msgget((key_t)12345,0777|IPC_CREAT);
 if(msgid==-1)
 {
  perror(“msgget”);
  exit(1);
 }
 while(running)
 {
  memset(&recivemsg,0,sizeof(MSG_REC));
  //printf(“please int msg:”);
  //fgets(buff,MAX_TEXT,stdin);
  //recivemsg.my_msg_type =1;
  //strcpy(recivemsg.msg_text,buff);
  if(msgrcv(msgid,(void *)&recivemsg,MAX_TEXT,0,0)==-1)
  {
   perror(“msgsnd”);
   exit(1);
  }
  printf(“the receive msg :%s”,recivemsg.msg_text);
  
  if(strncmp(recivemsg.msg_text,”end”,3)==0)
  {
   printf(“the program will exit\n”);
   running=0;
  }
 }
 return 0;
}

新葡京32450网址 1

=======================================================

PTRACE_ME

CH3 预微处理器

struct my_msg_st
{
 int my_msg_type;
 char msg_text[MAX_TEXT];
};
typedef struct my_msg_st  MSG_ST;

 

 

  1. debug格局下能够运作 release下运作不了,用宏定义完毕

    #define DEBUG 1

     

    int main()

    {

    int i = 2;

    #if DEBUG

    cout << “debugmod” << endl;

int main()
{
 int msgid;
 unsigned char running=1;
 char buff[MAX_TEXT];
 MSG_ST  sendmsg;
 
 msgid=msgget((key_t)12345,0777|IPC_CREAT);
 if(msgid==-1)
 {
  perror(“msgget”);
  exit(1);
 }
 while(running)
 {
  memset(&sendmsg,0,sizeof(MSG_ST));
  printf(“please int msg:”);
  fgets(buff,MAX_TEXT,stdin);
  sendmsg.my_msg_type =1;
  strcpy(sendmsg.msg_text,buff);
  if(msgsnd(msgid,(void *)&sendmsg,MAX_TEXT,0)==-1)
  {
   perror(“msgsnd”);
   exit(1);
  }
  
  if(strncmp(buff,”end”,3)==0)
  {
   printf(“the program will exit\n”);
   running=0;
  }
 }
 return 0;
}

linux下的C语言开采(线程等待)

PTRACE_POKEDATA

实例:

 

 

a.out        dummy.s      ptrace.txt  

libgpm.html  registers.c  syscallparams.c

dummy        ptrace.html  simple.c

ppadala@linux:~/ptrace > ./a.out

Write called with 1, 1075154944, 48

a.out        dummy.s      ptrace.txt

Write returned with 48

Write called with 1, 1075154944, 59

libgpm.html  registers.c  syscallparams.c

Write returned with 59

Write called with 1, 1075154944, 30

dummy        ptrace.html  simple.c

Write returned with 30

 

收纳端源代码

[cpp] view
plain copy

出口是那样的:

依据看 * 的位置。

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/types.h>
#include <sys/msg.h>
#define MAX_TEXT 512

 

 

\#endif 

 return 0; 

} 

 

下面这句话也可以实现上面的功能 

 

 

 linux下的C语言开垦(创造进度)

[cpp] view
plaincopy

  1.    return n;

  2. }

  3. int
    main()

  4. {

  5.    char* s = “123 abc”;

  6.    //方法一

  7.    long
    t = atox(s);

  8.    //方法二

  9.    char** ss = NULL;

  10.    long
    tt = strtol(s,ss,16);

  11.    cout << tt << endl;

出殡端源代码

[cpp] view
plain copy

 

要想将新的C++代码与旧的C代码混合编制程序,要求加上面的语句

struct my_msg_rec
{
 int my_msg_type;
 char msg_text[MAX_TEXT];
};
typedef struct my_msg_rec  MSG_REC;

    a) 创建socket
    b卡塔尔(قطر‎ 绑定socket到特定的ip地址
    c卡塔尔(قطر‎ 对socket举办侦听管理
    d卡塔尔国 选择socket,评释有客户端和服务器连接
    e卡塔尔 和顾客端循环收发报文
    f) 关闭socket

 

  1.    typedef void(Object::*Omf卡塔尔(卡塔尔(قطر‎;//起小名起的好

  2.    static Omf farray[3];// 成员函数指针数组

  3.  

  4. };

  5. Object::Omf Object::farray[3] = {

新葡京32450网址 2

linux下的C语言开垦(管道通讯)

 来点风趣的

  1. 早先化二维指针

    int **a;

    a = new int*[3];//行

        for(int i = 0; i < 4; ++i)

 

Pradeep Padala,

  1. 字符集

    回车 \r 换行 \n 回退 \b 警示 \a

     

     

     

 

 wait函数使用status变量来检查子进度是或不是已退出。它是用来剖断子进度是被ptrace暂停掉依旧曾经运维结束并退出。有大器晚成组宏能够因而status的值来判定进程的景色,比方WIFEXITED等,详细的情况能够考察wait(2卡塔尔(قطر‎man。

#ifdef _DEBUG

[cpp] view
plain copy

在率先某在那之中我们已经看见ptrace怎么获取子进程的种类调用以至更换系统调用的参数。在这里篇文章中,大家就要商讨什么在子进度中设置断点和往运营中的程序里插入代码。实际上调节和测量试验器正是用这种方法来安装断点和举行调节和测验句柄。与前方相符,这里的全部代码都以针对i386阳台的。

#endif // _DEBUG

 

  1. #include <sys/ptrace.h>  
  2. #include <sys/types.h>  
  3. #include <sys/wait.h>  
  4. #include <unistd.h>  
  5. #include <linux/user.h>  
  6. #include <sys/syscall.h>  
  7.   
  8. const int long_size = sizeof(long);  
  9.   
  10. void reverse(char *str)  
  11. {     
  12.     int i, j;  
  13.     char temp;  
  14.     for(i = 0, j = strlen(str) – 2;   
  15.         i <= j; ++i, –j) {  
  16.         temp = str[i];  
  17.         str[i] = str[j];  
  18.         str[j] = temp;  
  19.     }  
  20. }  
  21.   
  22. void getdata(pid_t child, long addr,   
  23.              char *str, int len)  
  24. {     
  25.     char *laddr;  
  26.     int i, j;  
  27.     union u {  
  28.             long val;  
  29.             char chars[long_size];  
  30.     }data;  
  31.   
  32.     i = 0;  
  33.     j = len / long_size;  
  34.     laddr = str;  
  35.     while(i < j) {  
  36.         data.val = ptrace(PTRACE_PEEKDATA,   
  37.                           child, addr + i * 4,   
  38.                           NULL);  
  39.         memcpy(laddr, data.chars, long_size);  
  40.         ++i;  
  41.         laddr += long_size;  
  42.     }  
  43.     j = len % long_size;  
  44.     if(j != 0) {  
  45.         data.val = ptrace(PTRACE_PEEKDATA,   
  46.                           child, addr + i * 4,   
  47.                           NULL);  
  48.         memcpy(laddr, data.chars, j);  
  49.     }  
  50.     str[len] = ”;  
  51. }  
  52.   
  53. void putdata(pid_t child, long addr,   
  54.              char *str, int len)  
  55. {     
  56.     char *laddr;  
  57.     int i, j;  
  58.     union u {  
  59.             long val;  
  60.             char chars[long_size];  
  61.     }data;  
  62.   
  63.     i = 0;  
  64.     j = len / long_size;  
  65.     laddr = str;  
  66.     while(i < j) {  
  67.         memcpy(data.chars, laddr, long_size);  
  68.         ptrace(PTRACE_POKEDATA, child,   
  69.                addr + i * 4, data.val);  
  70.         ++i;  
  71.         laddr += long_size;  
  72.     }  
  73.     j = len % long_size;  
  74.     if(j != 0) {  
  75.         memcpy(data.chars, laddr, j);  
  76.         ptrace(PTRACE_POKEDATA, child,   
  77.                addr + i * 4, data.val);  
  78.     }  
  79. }  
  80.   
  81. int main()  
  82. {     
  83.    pid_t child;  
  84.    child = fork();  
  85.    if(child == 0) {  
  86.       ptrace(PTRACE_TRACEME, 0, NULL, NULL);  
  87.       execl(“/bin/ls”, “ls”, NULL);  
  88.    }  
  89.    else {  
  90.       long orig_eax;  
  91.       long params[3];  
  92.       int status;  
  93.       char *str, *laddr;  
  94.       int toggle = 0;  
  95.       while(1) {  
  96.          wait(&status);  
  97.          if(WIFEXITED(status))  
  98.              break;  
  99.          orig_eax = ptrace(PTRACE_PEEKUSER,   
  100.                            child, 4 * ORIG_EAX,   
  101.                            NULL);  
  102.          if(orig_eax == SYS_write) {  
  103.             if(toggle == 0) {  
  104.                toggle = 1;  
  105.                params[0] = ptrace(PTRACE_PEEKUSER,   
  106.                                   child, 4 * EBX,   
  107.                                   NULL);  
  108.                params[1] = ptrace(PTRACE_PEEKUSER,   
  109.                                   child, 4 * ECX,   
  110.                                   NULL);  
  111.                params[2] = ptrace(PTRACE_PEEKUSER,  
  112.                                   child, 4 * EDX,   
  113.                                   NULL);  
  114.                str = (char *)calloc((params[2]+1)  
  115.                                  * sizeof(char));  
  116.                getdata(child, params[1], str,   
  117.                        params[2]);  
  118.                reverse(str);  
  119.                putdata(child, params[1], str,   
  120.                        params[2]);  
  121.             }  
  122.             else {  
  123.                toggle = 0;  
  124.             }  
  125.          }  
  126.       ptrace(PTRACE_SYSCALL, child, NULL, NULL);  
  127.       }  
  128.    }  
  129.    return 0;  
  130. }  
  1.   &Object::insert,

  2.   &Object::retreve,

  3.   &Object::update

  4. };

  5. void
    Object::process(int choice)

  6. {

  7.    if(choice >=0 && choice <=2)

  8.    {

  9.       (this->*farray[choice])();

  10.       cout << endl;

  11.    }

  12. }

  13. int
    main()

  14. {

  15.    Object o;

  16.    for(;;)

  17.    {

  18.       int choice;

  19.       cin >> choice;

  20.       if(choice >=0 && choice<=2)

  21.          o.process(choice);

  22.       else

  23.           break;

  24.    }

  25.    return 0;

  26. }

  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <signal.h>  
  4.   
  5. int value = 0;  
  6.   
  7. void func(int sig)  
  8. {  
  9.     printf(“I get a signal!\n”);  
  10.     value = 1;  
  11. }  
  12.   
  13. int main()  
  14. {  
  15.     signal(SIGINT, func);  
  16.   
  17.     while(0 == value)  
  18.         sleep(1);  
  19.   
  20.     return 0;  
  21. }  

 在backward和forward之间的跳转是为着使程序能够找到”hello
world” 字符串的地点。

1、<ctype.h>

[cpp] view
plain copy

在/proc/pid/maps中的每意气风发行都对应了经过中生龙活虎段内部存款和储蓄器区域。主函数的代码如下:

  1.    void
    retreve(){cout << “Object::retreve”;}

  2.    void
    insert(){cout << “Object::insert”;}

  3.    void
    update(){cout << “Object::update”;}

  4.    void
    process(int choice);

  5. private:

 linux下的C语言开采(非复信号管理)

 

  1. 函数指针

    针对非成员函数的指针:

    #include <Windows.h>

    #include <iostream>

     

    using namespace std;

     

    int (*fp卡塔尔国(int,int卡塔尔(قطر‎;//全局指针变量

 linux下的C语言开辟(进程等待)

  1. int main(int argc, char *argv[])  
  2. {     
  3.     pid_t traced_process;  
  4.     struct user_regs_struct oldregs, regs;  
  5.     long ins;  
  6.     int len = 41;  
  7.     char insertcode[] =  
  8.         “/xeb/x15/x5e/xb8/x04/x00”  
  9.         “/x00/x00/xbb/x02/x00/x00/x00/x89/xf1/xba”  
  10.         “/x0c/x00/x00/x00/xcd/x80/xcc/xe8/xe6/xff”  
  11.         “/xff/xff/x48/x65/x6c/x6c/x6f/x20/x57/x6f”  
  12.         “/x72/x6c/x64/x0a/x00”;  
  13.     char backup[len];  
  14.     long addr;  
  15.     if(argc != 2) {  
  16.         printf(“Usage: %s <pid to be traced> “,   
  17.                argv[0], argv[1]);  
  18.         exit(1);  
  19.     }  
  20.     traced_process = atoi(argv[1]);  
  21.     ptrace(PTRACE_ATTACH, traced_process,   
  22.            NULL, NULL);  
  23.     wait(NULL);  
  24.     ptrace(PTRACE_GETREGS, traced_process,   
  25.            NULL, &regs);  
  26.     addr = freespaceaddr(traced_process);  
  27.     getdata(traced_process, addr, backup, len);  
  28.     putdata(traced_process, addr, insertcode, len);  
  29.     memcpy(&oldregs, &regs, sizeof(regs));  
  30.     regs.eip = addr;  
  31.     ptrace(PTRACE_SETREGS, traced_process,   
  32.            NULL, &regs);  
  33.     ptrace(PTRACE_CONT, traced_process,   
  34.            NULL, NULL);  
  35.     wait(NULL);  
  36.     printf(“The process stopped, Putting back ”  
  37.            “the original instructions “);  
  38.     putdata(traced_process, addr, backup, len);  
  39.     ptrace(PTRACE_SETREGS, traced_process,   
  40.            NULL, &oldregs);  
  41.     printf(“Letting it continue with ”  
  42.            “original flow “);  
  43.     ptrace(PTRACE_DETACH, traced_process,   
  44.            NULL, NULL);  
  45.     return 0;  
  46. }  

char a = ‘A’;

    
不管在Windows平台上面仍然在Linux平台下边,互连网编制程序皆乃十分重要的。在网络发达的前几日,大家的生存基本樱笋时经离不开互连网了。我们得以用互联网干非常多的事务,比方说IM谈心、FTP下载、电子银行、网上购物、在线娱乐、电子邮件的收发等等。所以说,对于二个软件的开辟者来讲,借使说他不会开展互连网程序的开拓,那便是难以置信的。

以上的事例中大家追踪了write系统调用,而ls命令的实行将发出七个write系统调用。使用PTRACE_SYSCALL作为ptrace的首先个参数,使功底在子进度做出系统调用只怕准备退出的时候抛锚它。这种表现与运用PTRACE_CONT,然后在下一个种类调用/进度退出时停顿它是等价的。

  1. 运算符重载规定,必需有贰个为顾客自定义类型
  2. 局地出口没用心到的函数:

    float x = 123.456, y = 12345;

    //cout.precision(2卡塔尔国;
    //展现四个有效值,其余是不错计数法

    //cout << x << ” ” <<
    y << endl;

     

 

 

  1. #include <Windows.h>

  2. #include <iostream>

  3.  

  4. using
    namespace std;

  5.  

  6. class
    Object

  7. {

  8. public:

  1. #include <stdio.h>  
  2. #include <pthread.h>  
  3. #include <unistd.h>  
  4. #include <stdlib.h>  
  5.   
  6. static int value = 0;  
  7. pthread_mutex_t mutex;  
  8.   
  9. void func(void* args)  
  10. {  
  11.     while(1)  
  12.     {  
  13.         pthread_mutex_lock(&mutex);  
  14.         sleep(1);  
  15.         value ++;  
  16.         printf(“value = %d!\n”, value);  
  17.         pthread_mutex_unlock(&mutex);  
  18.     }  
  19. }  
  20.   
  21. int main()  
  22. {  
  23.     pthread_t pid1, pid2;  
  24.     pthread_mutex_init(&mutex, NULL);  
  25.   
  26.     if(pthread_create(&pid1, NULL, func, NULL))  
  27.     {  
  28.         return -1;  
  29.     }  
  30.   
  31.     if(pthread_create(&pid2, NULL, func, NULL))  
  32.     {  
  33.         return -1;  
  34.     }  
  35.   
  36.     while(1)  
  37.         sleep(0);  
  38.   
  39.     return 0;  
  40. }  

PTRACE_GETREGS

 

 
  Linux系统自个儿为经过间通讯提供了非常多的不二等秘书技,举个例子说管道、分享内部存款和储蓄器、socket通讯等。管道的利用十一分简便,在开立了无名氏管道之后,大家只供给从三个管道发送数据,再从此外二个管道选用多少就能够。

 Ptrace有五个参数

CH4 C规范库之风流洒脱 : 面向合格的程序猿

linux下的C语言开垦(互连网编制程序)

 在i386系列中(本文中保有的代码都以面向i386系统State of Qatar,系统调用号将归入%eax,它的参数则相继归入%ebx,
%ecx, %edx, %esi 和 %edi。 比方,在以下的调用

  1. 包裹与不完全类型

    利用与源类相符的类完成,就是重新定义叁个与源类形似的类,然后再一次打包一下。

  1. [test@localhost thread]$ ./thread  
  2. this is func!  
  3. this is end of main!  

获得寄放器值得例子如下:

  1.    return 0;

  2. }

     

  1. #include <stdio.h>  
  2. #include <unistd.h>  
  3. #include <stdlib.h>  
  4. #include <string.h>  
  5.   
  6. int pipe_default[2];    
  7.   
  8. int main()  
  9. {  
  10.     pid_t pid;  
  11.     char buffer[32];  
  12.   
  13.     memset(buffer, 0, 32);  
  14.     if(pipe(pipe_default) < 0)  
  15.     {  
  16.         printf(“Failed to create pipe!\n”);  
  17.         return 0;  
  18.     }  
  19.   
  20.     if(0 == (pid = fork()))  
  21.     {  
  22.         close(pipe_default[1]);  
  23.         sleep(5);  
  24.         if(read(pipe_default[0], buffer, 32) > 0)  
  25.         {  
  26.             printf(“Receive data from server, %s!\n”, buffer);  
  27.         }  
  28.         close(pipe_default[0]);  
  29.     }  
  30.     else  
  31.     {  
  32.         close(pipe_default[0]);  
  33.         if(-1 != write(pipe_default[1], “hello”, strlen(“hello”)))  
  34.         {  
  35.             printf(“Send data to client, hello!\n”);  
  36.         }  
  37.         close(pipe_default[1]);  
  38.         waitpid(pid, NULL, 0);  
  39.     }  
  40.   
  41.     return 1;  
  42. }  

 

cout << “debugmod” << endl;

   
在最早介绍互连网编程的艺术以前,大家能够回想一下Computer网络的连带文化。最近结束,大家选用的最多网络公约照旧tcp/ip网络。常常来讲,我们习惯上称作tcp/ip协议栈。至于合同栈分成几层,有三种说法。黄金年代种是五层,豆蔻梢头种是七层,作者个人小编也比较趋向于五层的剪切方法。我们能够由此下边包车型客车图看看公约栈是怎么划分的。

 当三个进程调用了 ptrace( PTRACE_TRACEME,
…卡塔尔(قطر‎之后,内核为该进程设置了一个标记,评释该进度将被盯梢。内核中的相关原代码如下:

  1.       s++;

  2.    long
    sum;

  3.    for(sum = 0L; isxdigit(*s); ++s)

  4.    {

  5.       int digit;

  6.       if(isdigit(*s))

  7.          digit = *s – ‘0’;

  8.       else

  9.          digit = toupper(*s) – ‘A’ +
    10;

  10.       sum = sum*16L + digit;

  11.    }

  12.    return sum;

  13. }

  14.  

  15. long
    atox(char*s)

  16. {

  17.    char
    xdigs[] = {0123456789ABCDEF};

  18.    long
    sum;

  19.    while(isspace(*s))

  20.       s++;

  21.    for(sum = 0; isxdigit(*s); ++s)

  22.    {

  23.       int digit = strchr(xdigs,toupper(*sState of Qatar) –
    xdigs;//找到指针的岗位,即数字的岗位(0-15取值)找寻字符串xdigs中首先次面世字串 (*s) 的位置。

  24.       sum = sum*16L + digit;

  25.    }

  26. }

  27. long
    atox(char *s)

  28. {

  29.    long
    n = 0;

    1.    sscanf(s,”%lx”,&nState of Qatar; //
      仿照效法代码:
  1. [test@localhost pipe]$ ./pipe  
  2. Send data to client, hello!  
  3. Receive data from server, hello!  

 

extern “C” void f(卡塔尔(قطر‎; //f(卡塔尔国在C处境下被编写翻译

 

基本知识

  1. 打字与印刷地址

    Printf(“%p”,s);

    Cout<<“address: “<<&s;

 

 

//cout.setf(ios::showpoint);//显示末尾的0 

 //cout &lt;&lt; x &lt;&lt; " " &lt;&lt;
y &lt;&lt; endl; 

 

 cout.setf(ios::showpos);//显示符号


 cout &lt;&lt; x &lt;&lt; " " &lt;&lt; y
&lt;&lt; endl; 

 

ppadala@linux:~/ptrace > ls

a.out        dummy.s      ptrace.txt

libgpm.html  registers.c  syscallparams.c

dummy        ptrace.html  simple.c

ppadala@linux:~/ptrace > ./a.out

txt.ecartp      s.ymmud      tuo.a

c.sretsiger     lmth.mpgbil  c.llacys_egnahc

c.elpmis        lmth.ecartp  ymmud

CH1 更好的C

[cpp] view
plain copy

 调节和测量试验器是怎么设置断点的吧?平常是将方今将在执行的下令替换来trap指令,于是被调治将养的程序就能够在这里地停滞,当时调节和测验器就足以观测被调试程序的新闻了。被调节和测量检验程序恢复生机运行之后调节和测量试验器会把原指令再放回来。这里是多少个例证:

分布的函数: is类别。Eg : isupper(卡塔尔国; islower(卡塔尔国; isspcace(卡塔尔国 等。

[cpp] view
plain copy

by Pradeep Padala

void (\*farray\[\])(void);
//可以定义在主函数外部,也可以在内部定义。 函数指针数组 

int Max(int a, int b) 

{ 

    if(a &gt; b) 

        return a; 

    else 

     return b; 

} 

int main() 

{ 

    fp = Max; 

    int a = fp(1,2); 

    cout &lt;&lt; a &lt;&lt; endl;


 return 0; 

} 

 

指向成员函数的指针:

\#include &lt;Windows.h&gt; 

\#include &lt;iostream&gt; 

 

using namespace std; 

 

class C 

{ 

public: 

    void f(){cout &lt;&lt; "C::f \\n";};


    void g(){cout &lt;&lt; "C::g \\n";};


    int Max(int a, int b) 

 { 

    if(a &gt; b) 

        return a; 

    else 

     return b; 

 } 

}; 

 

int main() 

{ 

 C c; 

 void (C::\*pmf)() = &C::f;
//定义指向成员函数的指针 


(c.\*pmf)();//指向成员函数的指针,与非成员函数的指针相比,语法上有点小变化,多了
对象.\* 

 pmf = &C::g; 

 (c.\*pmf)(); 

 

 int (C::\*fp)(int,int) = &C::Max;


 int aa = (c.\*fp)(3,4); 

 cout &lt;&lt; aa &lt;&lt; endl; 

 return 0; 

} 

 

 

 

 

  1. int main()  
  2. {     
  3.    int i;  
  4.     for(i = 0;i < 10; ++i) {  
  5.         printf(“My counter: %d “, i);  
  6.         sleep(2);  
  7.     }  
  8.     return 0;  
  9. }  
  1. 区别 const的位置

    Const char *p; 说明 *p是常量,不可能更改。

    Char* const p; 表达,p是常量,不可能校订。

 

使用GDB我们能够获得地点这段程序的机器码。运维GDB,然后对先后举行反汇编:

    { 

        a\[i\] = new int\[4\];//列


    } 

delete\[\] a; 

 

 

    int a\[\]\[4\] =
{{1,2,3},{4,5,6},{7,8,9}}; 

    int (\*p)\[4\] = a; 

 

    //p\[i\] == \*(p+i); 

    //p\[i\]\[j\] == \*(p\[i\]+j) ==
\*(\*(p+i)+j); 

 

 

    size\_t totals =
sizeof(a);//整个字节数 

    size\_t totalcols =
sizeof(a\[0\]);//整个列字节数 

    size\_t rows =
sizeof(a)/sizeof(a\[0\]); 

    size\_t cols =
sizeof(a\[0\])/sizeof(a\[0\]\[0\]); 

    for(int i = 0; i &lt; rows; ++i)


    { 

        for(int j = 0; j &lt; cols; ++j)


            cout &lt;&lt; p\[i\]\[j\]
&lt;&lt; " "; 

        cout &lt;&lt;endl; 

    } 

    cout &lt;&lt; rows &lt;&lt; " "
&lt;&lt; cols &lt;&lt; endl; 

 

 ptrace提供了对子进度张开单步的意义。 ptrace(PTRACE_SINGLESTEP,
…卡塔尔 会使基本在子进度的每一条指令施行前先将其拥塞,然后将调控权交给父进度。上边包车型客车事例能够查出子进度近期快要实践的指令。为了便于明白,小编用汇编写了那个受控程序,并非让您为c的库函数到底会作那多少个系统调用而嫌恶。

CH2 指针

相关文章

留下评论

网站地图xml地图