Memcpy int single pointer
===========================
* In this section, you are going to learn
.. panels::
:container: container pb-4
:column: col-lg-12 p-2
:card: shadow
How to do memcpy with integer single pointer ?
.. panels::
:container: container pb-4
:column: col-lg-12 p-2
:card: shadow
Topics in this section,
* :ref:`Single integer copy <sp_memcpy_ptr_int_sp_ex_1>`
* :ref:`Single integer copy using memcpy <sp_memcpy_ptr_int_sp_ex_2>`
* :ref:`Single integer copy using pointers <sp_memcpy_ptr_int_sp_ex_3>`
* :ref:`Single integer copy using pointers with memcpy <sp_memcpy_ptr_int_sp_ex_4>`
* :ref:`Single integer copy using pointers indexing and loop <sp_memcpy_ptr_int_sp_ex_5>`
* :ref:`Single integer copy using pointers increment and loop <sp_memcpy_ptr_int_sp_ex_6>`
* :ref:`Two Arrays copy : One int at a time with array indexing : Loop <sp_memcpy_ptr_int_sp_ex_7>`
* :ref:`Two Arrays copy : One int at a time with array indexing (pointer notation): Loop <sp_memcpy_ptr_int_sp_ex_8>`
* :ref:`Two Arrays copy : One int at a time with pointers indexing : Loop <sp_memcpy_ptr_int_sp_ex_9>`
* :ref:`Two Arrays copy : One int at a time with pointers incrementing : Loop <sp_memcpy_ptr_int_sp_ex_10>`
* :ref:`Two Arrays copy : memcpy using Array Names <sp_memcpy_ptr_int_sp_ex_11>`
* :ref:`Two Arrays copy : memcpy using pointer alias Names <sp_memcpy_ptr_int_sp_ex_12>`
* :ref:`Two Arrays copy : memcpy using Array Names : Relative position copy <sp_memcpy_ptr_int_sp_ex_13>`
* :ref:`Two Arrays copy : Extract part of array into another array <sp_memcpy_ptr_int_sp_ex_14>`
* :ref:`Single array : Change contents of Single array using a Single pointer <sp_memcpy_ptr_int_sp_ex_15>`
* :ref:`Single array : Change contents of Single array using memcpy <sp_memcpy_ptr_int_sp_ex_16>`
* :ref:`Use of standard memcpy on heap memory <sp_memcpy_ptr_int_sp_ex_17>`
* :ref:`Custom memcpy with single pointer : Pass single pointer to a function : Call by Value <sp_memcpy_ptr_int_sp_ex_18>`
* :ref:`Custom memcpy with single pointer : Pass single pointer to a function : Call by Reference <sp_memcpy_ptr_int_sp_ex_19>`
.. _sp_memcpy_ptr_int_sp_ex_1:
.. tab-set::
.. tab-item:: Single integer copy
* Step 1 : Define two integer variables
.. code-block:: c
int a = 5;
int b;
* Step 2 : Do integer copy
.. code-block:: c
b = a;
* Step 3 : Print integers
.. code-block:: c
printf("a = %d, b = %d\n", a, b);
* See full program below
.. code-block:: c
:linenos:
:emphasize-lines: 8
#include <stdio.h>
int main(void)
{
int a = 5;
int b;
b = a;
printf("a = %d, b = %d\n", a, b);
return 0;
}
* Output is as below
.. code-block:: c
a = 5, b = 5
.. _sp_memcpy_ptr_int_sp_ex_2:
.. tab-set::
.. tab-item:: Single integer copy using `memcpy`
* Step 1 : Define two integer variables
.. code-block:: c
int a = 5;
int b;
* Step 2 : Do integer copy
.. code-block:: c
memcpy(&b, &a, sizeof(int));
* Step 3 : Print integers
.. code-block:: c
printf("a = %d, b = %d\n", a, b);
* See full program below
.. code-block:: c
:linenos:
:emphasize-lines: 9
#include <stdio.h>
#include <string.h>
int main(void)
{
int a = 5;
int b;
memcpy(&b, &a, sizeof(int));
printf("a = %d, b = %d\n", a, b);
return 0;
}
* Output is as below
.. code-block:: c
a = 5, b = 5
.. _sp_memcpy_ptr_int_sp_ex_3:
.. tab-set::
.. tab-item:: Single integer copy using pointers
* Step 1 : Define two integer variables
.. code-block:: c
int a = 5;
int b;
* Step 2 : Define two pointers
.. code-block:: c
int *p;
int *q;
p = &a;
q = &b;
* Step 3 : Do integer copy
.. code-block:: c
*q = *p;
* Step 4 : Print integers
.. code-block:: c
printf("a = %d, b = %d\n", a, b);
* See full program below
.. code-block:: c
:linenos:
:emphasize-lines: 11,12
#include <stdio.h>
int main(void)
{
int a = 5;
int b;
int *p;
int *q;
p = &a;
q = &b;
*q = *p;
printf("a = %d, b = %d\n", a, b);
return 0;
}
* Output is as below
.. code-block:: c
a = 5, b = 5
.. _sp_memcpy_ptr_int_sp_ex_4:
.. tab-set::
.. tab-item:: Single integer copy using pointers with memcpy
* Step 1 : Define two integer variables
.. code-block:: c
int a = 5;
int b;
* Step 2 : Define two pointers
.. code-block:: c
int *p;
int *q;
p = &a;
q = &b;
* Step 3 : Do integer copy using memcpy
.. code-block:: c
memcpy(q, p, sizeof(int));
* Step 4 : Print integers
.. code-block:: c
printf("a = %d, b = %d\n", a, b);
* See full program below
.. code-block:: c
:linenos:
:emphasize-lines: 15
#include <stdio.h>
#include <string.h>
int main(void)
{
int a = 5;
int b;
int *p;
int *q;
p = &a;
q = &b;
memcpy(q, p, sizeof(int));
printf("a = %d, b = %d\n", a, b);
return 0;
}
* Output is as below
.. code-block:: c
a = 5, b = 5
.. _sp_memcpy_ptr_int_sp_ex_5:
.. tab-set::
.. tab-item:: Single integer copy using pointers indexing and loop
* Step 1 : Define two integer variables
.. code-block:: c
int a = 5;
int b;
* Step 2 : Define two pointers
.. code-block:: c
int *p;
int *q;
p = &a;
q = &b;
* Step 3 : Do integer copy using memcpy
.. code-block:: c
for (int i = 0; i < sizeof(int); i += 4)
{
q[i] = p[i];
}
* Step 4 : Print integers
.. code-block:: c
printf("a = %d, b = %d\n", a, b);
* See full program below
.. code-block:: c
:linenos:
:emphasize-lines: 14, 15, 16, 17
#include <stdio.h>
int main(void)
{
int a = 5;
int b;
int *p;
int *q;
p = &a;
q = &b;
for (int i = 0; i < sizeof(int); i += 4)
{
q[i] = p[i];
}
printf("a = %d, b = %d\n", a, b);
return 0;
}
* Output is as below
.. code-block:: c
a = 5, b = 5
.. _sp_memcpy_ptr_int_sp_ex_6:
.. tab-set::
.. tab-item:: Single integer copy using pointers increment and loop
* Step 1 : Define two integer variables
.. code-block:: c
int a = 5;
int b;
* Step 2 : Define two pointers
.. code-block:: c
int *p;
int *q;
p = &a;
q = &b;
* Step 3 : Do integer copy using memcpy
.. code-block:: c
for (int i = 0; i < sizeof(int); i += 4)
{
*q++ = *p++;
}
* Step 4 : Print integers
.. code-block:: c
printf("a = %d, b = %d\n", a, b);
* See full program below
.. code-block:: c
:linenos:
:emphasize-lines: 14, 15, 16, 17
#include <stdio.h>
int main(void)
{
int a = 5;
int b;
int *p;
int *q;
p = &a;
q = &b;
for (int i = 0; i < sizeof(int); i += 4)
{
*q++ = *p++;
}
printf("a = %d, b = %d\n", a, b);
return 0;
}
* Output is as below
.. code-block:: c
a = 5, b = 5
.. _sp_memcpy_ptr_int_sp_ex_7:
.. tab-set::
.. tab-item:: Two Arrays copy : One int at a time with array indexing : Loop
* Step 1 : Define two arrays
.. code-block:: c
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int b[10];
* Step 2 : Do copy
.. code-block:: c
for (int i = 0; i < sizeof(b) / sizeof(b[0]); i++)
{
b[i] = a[i];
}
* Step 3 : Print destination array
.. code-block:: c
for (int i = 0; i < sizeof(b) / sizeof(b[0]); i++)
{
printf("%d ", b[i]);
}
* See full program below
.. code-block:: c
:linenos:
:emphasize-lines: 10, 15
#include <stdio.h>
int main(void)
{
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int b[10];
for (int i = 0; i < sizeof(b) / sizeof(b[0]); i++)
{
b[i] = a[i];
}
for (int i = 0; i < sizeof(b) / sizeof(b[0]); i++)
{
printf("%d ", b[i]);
}
printf("\n");
return 0;
}
* Output is as below
.. code-block:: c
1 2 3 4 5 6 7 8 9 10
.. _sp_memcpy_ptr_int_sp_ex_8:
.. tab-set::
.. tab-item:: Two Arrays copy : One int at a time with array indexing (pointer notation): Loop
* Step 1 : Define two arrays
.. code-block:: c
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int b[10];
* Step 2 : Do copy
.. code-block:: c
for (int i = 0; i < sizeof(b) / sizeof(b[0]); i++)
{
*(b + i) = *(a + i);
}
* Step 3 : Print destination array
.. code-block:: c
for (int i = 0; i < sizeof(b) / sizeof(b[0]); i++)
{
printf("%d ", *(b + i) );
}
* See full program below
.. code-block:: c
:linenos:
:emphasize-lines: 10, 15
#include <stdio.h>
int main(void)
{
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int b[10];
for (int i = 0; i < sizeof(b) / sizeof(b[0]); i++)
{
*(b + i) = *(a + i);
}
for (int i = 0; i < sizeof(b) / sizeof(b[0]); i++)
{
printf("%d ", *(b + i) );
}
printf("\n");
return 0;
}
* Output is as below
.. code-block:: c
1 2 3 4 5 6 7 8 9 10
.. _sp_memcpy_ptr_int_sp_ex_9:
.. tab-set::
.. tab-item:: Two Arrays copy : One int at a time with pointers indexing : Loop
* Step 1 : Define two arrays
.. code-block:: c
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int b[10];
* Step 2 : Define two pointers
.. code-block:: c
int *p;
int *q;
p = a;
q = b;
* Step 3 : Do copy
.. code-block:: c
for (int i = 0; i < sizeof(b) / sizeof(b[0]); i++)
{
q[i] = p[i];
}
* See full program below
.. code-block:: c
:linenos:
:emphasize-lines: 16
#include <stdio.h>
int main(void)
{
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int b[10];
int *p;
int *q;
p = a;
q = b;
for (int i = 0; i < sizeof(b) / sizeof(b[0]); i++)
{
q[i] = p[i];
}
for (int i = 0; i < sizeof(b) / sizeof(b[0]); i++)
{
printf("%d ", b[i] );
}
printf("\n");
return 0;
}
* Output is as below
.. code-block:: c
1 2 3 4 5 6 7 8 9 10
.. _sp_memcpy_ptr_int_sp_ex_10:
.. tab-set::
.. tab-item:: Two Arrays copy : One int at a time with pointers incrementing : Loop
* Step 1 : Define two arrays
.. code-block:: c
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int b[10];
* Step 2 : Define two pointers
.. code-block:: c
int *p;
int *q;
p = a;
q = b;
* Step 3 : Do copy
.. code-block:: c
for (int i = 0; i < sizeof(b) / sizeof(b[0]); i++)
{
*q++ = *p++;
}
* See full program below
.. code-block:: c
:linenos:
:emphasize-lines: 16
#include <stdio.h>
int main(void)
{
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int b[10];
int *p;
int *q;
p = a;
q = b;
for (int i = 0; i < sizeof(b) / sizeof(b[0]); i++)
{
*q++ = *p++;
}
for (int i = 0; i < sizeof(b) / sizeof(b[0]); i++)
{
printf("%d", b[i] );
}
printf("\n");
return 0;
}
* Output is as below
.. code-block:: c
1 2 3 4 5 6 7 8 9 10
.. _sp_memcpy_ptr_int_sp_ex_11:
.. tab-set::
.. tab-item:: Two Arrays copy : memcpy using Array Names
* Step 1 : Define two arrays
.. code-block:: c
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int b[10];
* Step 2 : Do copy
.. code-block:: c
memcpy(b, a, sizeof(b));
* See full program below
.. code-block:: c
:linenos:
:emphasize-lines: 9
#include <stdio.h>
#include <string.h>
int main(void)
{
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int b[10];
memcpy(b, a, sizeof(b));
for (int i = 0; i < sizeof(b) / sizeof(b[0]); i++)
{
printf("%d ", b[i] );
}
printf("\n");
return 0;
}
* Output is as below
.. code-block:: c
1 2 3 4 5 6 7 8 9 10
.. _sp_memcpy_ptr_int_sp_ex_12:
.. tab-set::
.. tab-item:: Two Arrays copy : memcpy using pointer alias Names
* Step 1 : Define two arrays
.. code-block:: c
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int b[10];
* Step 2 : Define Pointers
.. code-block:: c
int *p;
int *q;
p = a;
q = b;
* Step 3 : Do copy
.. code-block:: c
memcpy(q, p, sizeof(b));
* See full program below
.. code-block:: c
:linenos:
:emphasize-lines: 15
#include <stdio.h>
#include <string.h>
int main(void)
{
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int b[10];
int *p;
int *q;
p = a;
q = b;
memcpy(q, p, sizeof(b));
for (int i = 0; i < sizeof(b) / sizeof(b[0]); i++)
{
printf("%d ", b[i] );
}
printf("\n");
return 0;
}
* Output is as below
.. code-block:: c
1 2 3 4 5 6 7 8 9 10
.. _sp_memcpy_ptr_int_sp_ex_13:
.. tab-set::
.. tab-item:: Two Arrays copy : memcpy using Array Names : Relative position copy
* Step 1 : Define two arrays
.. code-block:: c
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int b[10];
* Step 2 : Use first 3 integers in array "b"
.. code-block:: c
b[0] = 10;
b[1] = 20;
b[2] = 30;
* Step 3 : Use remainig 7 integers in array "b" to copy contents from array "a"
.. code-block:: c
memcpy(b + 3, a + 3, sizeof(b) - (3 * sizeof(int)) );
* Step 4 : Print the contents of array "b"
.. code-block:: c
for (int i = 0; i < sizeof(b) / sizeof(b[0]); i++)
{
printf("%d", b[i]);
}
* See full program below
.. code-block:: c
:linenos:
#include <stdio.h>
#include <string.h>
int main(void)
{
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int b[10];
// Clear garbage contents in array "b"
memset(b, 0, sizeof(b));
// Use first 3 integers in array "b"
b[0] = 10;
b[1] = 20;
b[2] = 30;
// Use remainig 7 integers in array "b" to copy contents from array "a"
memcpy(b + 3, a + 3, sizeof(b) - (3 * sizeof(int)) );
for (int i = 0; i < sizeof(b) / sizeof(b[0]); i++)
{
printf("%d", b[i]);
}
printf("\n");
return 0;
}
* Output is as below
.. code-block:: c
10 20 30 4 5 6 7 8 9 10
.. _sp_memcpy_ptr_int_sp_ex_14:
.. tab-set::
.. tab-item:: Two Arrays copy : Extract part of array into another array
* Step 1 : Define two arrays
.. code-block:: c
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int b[10];
* Step 2 : Define two pointers
.. code-block:: c
int *p;
int *q;
* Step 3 : Extract part of data from array "a" into array "b"
.. code-block:: c
p = a + 3;
q = a + 7;
for (int i = 0; p <= q; i++)
{
b[i] = *p;
p++;
}
* Step 4 : Print the contents of array "b"
.. code-block:: c
for (int i = 0; i < sizeof(b) / sizeof(b[0]); i++)
{
printf("%d", b[i]);
}
* See full program below
.. code-block:: c
:linenos:
#include <stdio.h>
#include <string.h>
int main(void)
{
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int b[10];
int *p;
int *q;
// Clear garbage contents in array "b"
memset(b, 0, sizeof(b));
// Extract part of data from array "a" into array "b"
p = a + 3;
q = a + 7;
for (int i = 0; p <= q; i++)
{
b[i] = *p;
p++;
}
// Print the contents of array "b"
for (int i = 0; i < sizeof(b) / sizeof(b[0]); i++)
{
printf("%d ", b[i]);
}
printf("\n");
return 0;
}
* Output is as below
.. code-block:: c
4 5 6 7 8 0 0 0 0 0
.. _sp_memcpy_ptr_int_sp_ex_15:
.. tab-set::
.. tab-item:: Single array : Change contents of Single array using a Single pointer
* Step 1 : Define a Single Dimension array
.. code-block:: c
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
* Step 2 : Define a Single pointer
.. code-block:: c
int *p;
* Step 3 : Change part of the array using a single pointer
.. code-block:: c
p = a + 3;
p[0] = 100; // p[0] is equal to a[3]
p[1] = 200; // p[1] is equal to a[4]
p[2] = 300; // p[2] is equal to a[5]
* Step 4 : Print the contents of array "a"
.. code-block:: c
for(int i = 0; i < sizeof(a) / sizeof(a[0]) ; i++)
{
printf("%d", a[i]);
}
* See full program below
.. code-block:: c
:linenos:
#include <stdio.h>
int main(void)
{
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int *p;
// Change part of the array using a single pointer
p = a + 3;
p[0] = 100; // p[0] is equal to a[3]
p[1] = 200; // p[1] is equal to a[4]
p[2] = 300; // p[2] is equal to a[5]
// Print the contents of array "a"
for(int i = 0; i < sizeof(a) / sizeof(a[0]) ; i++)
{
printf("%d ", a[i]);
}
printf("\n");
return 0;
}
* Output is as below
.. code-block:: c
1 2 3 100 200 300 7 8 9 10
.. _sp_memcpy_ptr_int_sp_ex_16:
.. tab-set::
.. tab-item:: Single array : Change contents of Single array using memcpy
* Step 1 : Define two arrays
.. code-block:: c
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int b[10] = {100, 200, 300};
* Step 2 : Change part of array "a" by copying contents from array "b"
.. code-block:: c
memcpy(a + 3, b, 3 * sizeof(int));
* Step 3 : Print the contents of array "a"
.. code-block:: c
for(int i = 0; i < sizeof(a) / sizeof(a[0]) ; i++)
{
printf("%d", a[i]);
}
* See full program below
.. code-block:: c
:linenos:
#include <stdio.h>
#include <string.h>
int main(void)
{
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int b[10] = {100, 200, 300};
// Change part of array "a" by copying contents from array "b"
memcpy(a + 3, b, 3 * sizeof(int));
// Print the contents of array "a"
for(int i = 0; i < sizeof(a) / sizeof(a[0]) ; i++)
{
printf("%d", a[i]);
}
printf("\n");
return 0;
}
* Output is as below
.. code-block:: c
1 2 3 100 200 300 7 8 9 10
.. _sp_memcpy_ptr_int_sp_ex_17:
.. tab-set::
.. tab-item:: Use of standard memcpy on heap memory
* Step 1 : Define an array and a pointer
.. code-block:: c
int p[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int *q;
* Step 2 : Allocate heap memory to pointer
.. code-block:: c
q = malloc(10 * sizeof(int));
* Step 3 : Clear garbage contents of allocated heap memory
.. code-block:: c
memset(q, 0, 10 * sizeof(int));
* Step 4 : Use standard "memcpy" on heap memory
.. code-block:: c
memcpy(q, p, 10 * sizeof(int));
* Step 5 : Free heap memory after use
.. code-block:: c
free(q);
* See full program below
.. code-block:: c
:linenos:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void)
{
int p[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int *q;
// Allocate 10 bytes memory in heap. Let "q" point to it
q = malloc(10 * sizeof(int));
// Clear garbage contents of allocated heap memory
memset(q, 0, 10 * sizeof(int));
// Use standard "memcpy" to copy contents into heap memory pointed by "q"
memcpy(q, p, 10 * sizeof(int));
// Use "%d" to print contents heap memory pointed by "q"
for(int i = 0; i < sizeof(p) / sizeof(p[0]); i++)
{
printf("%d ", q[i]);
}
printf("\n");
free(q);
}
* Output is as below
.. code-block:: c
1 2 3 4 5 6 7 8 9 10
.. _sp_memcpy_ptr_int_sp_ex_18:
.. tab-set::
.. tab-item:: Custom memcpy with single pointer : Pass single pointer to a function : Call by Value
* Step 1 : Define two arrays
.. code-block:: c
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int b[10];
* Step 2 : Define two pointers
.. code-block:: c
int *p;
int *q;
p = a;
q = b;
* Step 3 : Pass single pointer to a function : Call by Value
.. code-block:: c
my_memcpy_1(q, p, sizeof(b));
* Step 4 : Define `my_memcpy_1` function
.. code-block:: c
void my_memcpy_1(int *dest, int *src, int size)
{
memcpy(dest, src, size);
}
* See full program below
.. code-block:: c
:linenos:
#include <stdio.h>
#include <string.h>
void my_memcpy_1(int *dest, int *src, int size)
{
memcpy(dest, src, size);
}
int main(void)
{
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int b[10];
int *p;
int *q;
p = a;
q = b;
memset(b, 0, sizeof(b));
my_memcpy_1(q, p, sizeof(b));
// Use "%d" to print contents heap memory pointed by "q"
for(int i = 0; i < sizeof(b) / sizeof(b[0]); i++)
{
printf("%d ", b[i]);
}
printf("\n");
return 0;
}
* Output is as below
.. code-block:: c
1 2 3 4 5 6 7 8 9 10
.. _sp_memcpy_ptr_int_sp_ex_19:
.. tab-set::
.. tab-item:: Custom memcpy with single pointer : Pass single pointer to a function : Call by Reference
* Step 1 : Define two arrays
.. code-block:: c
int p[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int b[10];
* Step 2 : Define two pointers
.. code-block:: c
int *p;
int *q;
p = a;
q = b;
* Step 3 : Pass single pointer to a function : Call by Reference
.. code-block:: c
my_memcpy_2(&q, &p, sizeof(b));
* Step 4 : Define `my_memcpy_2` function
.. code-block:: c
void my_memcpy_2(int **dest, int **src, int size)
{
memcpy(*dest, *src, size);
}
* See full program below
.. code-block:: c
:linenos:
#include <stdio.h>
#include <string.h>
void my_memcpy_2(int **dest, int **src, int size)
{
memcpy(*dest, *src, size);
}
int main(void)
{
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int b[10];
int *p;
int *q;
p = a;
q = b;
memset(b, 0, sizeof(b));
my_memcpy_2(&q, &p, sizeof(b));
// Use "%d" to print contents heap memory pointed by "q"
for(int i = 0; i < sizeof(b) / sizeof(b[0]); i++)
{
printf("%d ", b[i]);
}
printf("\n");
return 0;
}
* Output is as below
.. code-block:: c
1 2 3 4 5 6 7 8 9 10
.. card:: See Also
* Current Module
* :doc:`../memcpy_ptr`
* Previous Module
* :doc:`../../funcs_n_ptrs/funcs_n_ptrs`
* Next Module
* :doc:`../../const_ptr/const_ptr`
* Other Modules
* :doc:`../../variable_and_ptr/variable_and_ptr`
* :doc:`../../array_n_ptrs/array_n_ptrs`
* :doc:`../../malloc_ptr/malloc_ptr`
* :doc:`../../typecasting_n_ptr/typecasting_n_ptr`
* :doc:`../../void_ptr/void_ptr`
* :doc:`../../array_of_ptr/array_of_ptr`
* :doc:`../../ptr_to_array/ptr_to_array`
* :doc:`../../function_ptr/function_ptr`
* :doc:`../../pre_incr_ptr/pre_incr_ptr`
* :doc:`../../post_incr_ptr/post_incr_ptr`
* :doc:`../../pre_decr_ptr/pre_decr_ptr`
* :doc:`../../post_decr_ptr/post_decr_ptr`