Advertisement
dllbridge

Untitled

Oct 19th, 2024
99
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 3.94 KB | None | 0 0
  1.  
  2. #include     <stdio.h>
  3.  
  4.  
  5.  
  6.  
  7. void foo(char *);
  8.  
  9.  
  10. ////////////////////////////////////////
  11. int main()                            //
  12. {
  13.     char  sz[11] = "SONY";                    //{20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30};
  14.    
  15.     foo(&sz[2]);
  16. }
  17.  
  18.  
  19. ////////////////////////////////////////
  20. void foo(char *p)
  21. {
  22.     p -= 2;
  23.  
  24.     printf("p[0] = %c  \n", p[0]);    
  25.     printf("p[1] = %c  \n", p[1]);  
  26.      
  27. }
  28.  
  29.  
  30.  
  31.  
  32.  
  33.  
  34.  
  35.  
  36.  
  37.  
  38.  
  39.  
  40.  
  41.  
  42.  
  43. /*
  44. #include     <stdio.h>
  45.  
  46.  
  47.  
  48.  
  49. void foo(int *);
  50.  
  51.  
  52. ////////////////////////////////////////
  53. int main()                            //
  54. {
  55.     int  nArr[11] = {20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30};
  56.    
  57.     foo(&nArr[1]);
  58. }
  59.  
  60.  
  61. ////////////////////////////////////////
  62. void foo(int *p)
  63. {
  64.  
  65.     printf("nArr[0] = %d  \n", p[0]);    
  66.     printf("nArr[1] = %d  \n", p[1]);  
  67.      
  68. }
  69.  
  70. */
  71.  
  72.  
  73.  
  74.  
  75.  
  76.  
  77.  
  78.  
  79.  
  80.  
  81.  
  82.  
  83.  
  84.  
  85.  
  86. /*
  87.  
  88. void foo(int *);
  89.  
  90.  
  91. ////////////////////////////////////////
  92. int main()                            //
  93. {
  94.     int  nArr[11] = {20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30};
  95.    
  96.     foo(&nArr[0]);
  97. }
  98.  
  99.  
  100. ////////////////////////////////////////
  101. void foo(int *nArr)
  102. {
  103.      
  104.      
  105.     printf(" nArr    = %d  \n",  nArr   );
  106.     printf(" nArr    = %d  \n", &nArr[0]);    
  107.     printf("&nArr[1] = %d  \n", &nArr[1]);
  108.    
  109.          
  110. }
  111.  
  112.  
  113.  
  114.  
  115. */
  116.  
  117.  
  118.  
  119.  
  120.  
  121.  
  122.  
  123.  
  124.  
  125.  
  126.  
  127.  
  128.  
  129.  
  130.  
  131.  
  132.  
  133.  
  134. /*
  135. #include     <stdio.h>
  136.  
  137.  
  138. int n  = 444;
  139.  
  140. int *p =  &n;
  141.  
  142.  
  143. ////////////////////////////////////////
  144. int main()                            //
  145. {
  146.    
  147.    
  148.     printf(" n = %d  \n", &n);
  149.     printf(" p = %d  \n",  p);    
  150.     printf(" n = %7d \n",  n);
  151.     printf("*p = %7d \n", *p);    
  152. }
  153.    
  154.  
  155. */
  156.  
  157.  
  158.  
  159.  
  160.  
  161.  
  162.  
  163.  
  164.  
  165.  
  166.  
  167.  
  168.  
  169.  
  170.  
  171.  
  172.  
  173.  
  174.  
  175.  
  176.  
  177.  
  178.  
  179.  
  180. /*
  181. #include     <stdio.h>
  182.  
  183.  
  184. int n  = 444;
  185.  
  186. int *p =  &n;
  187.  
  188.  
  189. ////////////////////////////////////////
  190. int main()                            //
  191. {
  192.    
  193.    
  194.     printf("n = %d\n", &n);
  195.     printf("p = %d\n",  p);    
  196.    // printf("n = %d\n", &n);
  197.     printf("sizeof(p) = %d\n", sizeof(p));
  198.     printf("sizeof(n) = %d\n", sizeof(char));        
  199. }
  200.    
  201.    
  202.    
  203.     */
  204.    
  205.    
  206.    
  207.    
  208.    
  209.    
  210.    
  211.    
  212.    
  213.    
  214.    
  215.    
  216.    
  217.    
  218.    
  219.    
  220.    
  221.    
  222.    
  223. /*
  224.  
  225. #include     <stdio.h>
  226.  
  227.  
  228. int n  = 444;
  229.  
  230. int *p =   0;
  231.  
  232.  
  233. ////////////////////////////////////////
  234. int main()                            //
  235. {
  236.    
  237.    
  238.    
  239. }
  240.    
  241.    
  242.    
  243.    
  244.     */
  245.    
  246.    
  247.    
  248.    
  249.    
  250.    
  251.    
  252.    
  253.    
  254.    
  255.    
  256.    
  257.    
  258.    
  259.    
  260.    
  261.    
  262.    
  263.    
  264.    
  265.    
  266.    
  267.    
  268. /*
  269. #include     <stdio.h>
  270.  
  271.  
  272. void foo(int*);
  273.  
  274.  
  275. ////////////////////////////////////////
  276. int main()                            //
  277. {
  278.    
  279.     int   nArr[11] = {20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30};
  280.    
  281.     foo(nArr);
  282.    
  283.     int i = 0;
  284.    
  285. L_01: if(i < 11)                        //               çàäàåì goto
  286.       {
  287.          printf("%d ", nArr[i]);
  288.          i ++;
  289.          goto L_01;
  290.       }
  291.        
  292. return 0;
  293. }
  294.  
  295.  
  296. ////////////////////////////////////////
  297. void foo(int *nArr)                   //
  298. {
  299.      
  300.     int i = 0;
  301.    
  302. L_01: nArr[i] = nArr[i] -10;                                //                çàäàåì goto
  303.    
  304.       i++;
  305.        
  306.       if(i < 11) goto L_01;
  307.    
  308. }
  309. */
  310.  
  311.  
  312. /*
  313. #include     <stdio.h>
  314.  
  315.  
  316. void foo(int*, int*);
  317.  
  318.  
  319. ////////////////////////////////////////
  320. int main()                            //
  321. {
  322.    
  323.     int   nArr[11] = {20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30},
  324.         newarr[11];
  325.    
  326.     foo(nArr,newarr);
  327.    
  328.     int i = 0;
  329.    
  330. L_01: if(i < 11)                        //               çàäàåì goto
  331.       {
  332.          printf("%d ",newarr[i]);
  333.          i ++;
  334.          goto L_01;
  335.       }
  336.        
  337. return 0;
  338. }
  339.  
  340.  
  341. ////////////////////////////////////////
  342. void foo(int *nArr, int *newarr)      //
  343. {
  344.      
  345.     int i = 0;
  346.    
  347. gt: if(i < 11)                         //                çàäàåì goto
  348.     {
  349.         newarr[i] = nArr[i]-10;
  350.         i++;
  351.         goto gt;
  352.     }
  353. }
  354. */
  355.  
  356.  
  357.  
  358.  
  359.  
  360.  
  361.  
  362.  
  363.  
  364.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement