Technique 1 :
Length of the string without loop and without recursion (only using printf and gets)
#include <stdio.h>
int main()
{
char str[100];
printf("Enter a string: ");
printf( "\rLength is: %d",
printf("Entered string is: %s\n", gets(str)) - 20
);
return 0;
}
Output:
Enter a string: GeeksforGeeks
Entered string is: GeeksforGeeks
Length is: 13
The idea is to use return values of printf() and gets().
gets() returns the entered string length.
printf() returns the number of characters successfully written on output.
Source:
http://www.geeksforgeeks.org/find-length-string-without-strlen-loop/
technique 2:
- to get the long line with spcae, you can only use gets(string name). scanf will not help
- to compare the space of the string you can use if(str[index] == 32). since the 32 is the ASCII value for the 32. refer ASCII table at http://www.asciitable.com/
Example:
SELVATHA-M-V0HE:test selvatha$ more scan.c
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main() {
char name1[100]={0};
char name2[100]={0};
printf("\n================================ \n");
printf("\n Scanning using scanf without space");
printf("\n================================ \n");
printf("\n enter the name1\t:");
scanf("%s",name1);
printf("\n string is \t:%s\n",name1);
printf("\n================================ \n");
printf("\n Scanning using gets with space");
printf("\n================================ \n");
printf("\n enter the name2\t:");
gets(name2);
printf("\n string is \t:%s\n",name2);
return 0;
}
SELVATHA-M-V0HE:test selvatha$ ./a.out
================================
Scanning using scanf without space
================================
enter the name1 :selva kumar hi
string is :selva
================================
Scanning using gets with space
================================
warning: this program uses gets(), which is unsafe. --->
---> program terminated as it wont allow us to use the gets which create a buffer
overflow. this output is waste.
enter the name2 :
string is : kumar hi
Awareness:
A1.
strcpy will
do null termination :-)
but
strncpy will
not do null termination :-(
stcpy:
The strcpy() function copies the string pointed to by src, including
the terminating null byte ('\0'), to the buffer pointed to by dest
stncpy:
The strncpy() function is similar, except that at most n bytes of src
are copied. Warning: If there is no null byte among the first n
bytes of src, the string placed in dest will not be null-terminated.
A simple implementation of strncpy() might be:
char *
strncpy(char *dest, const char *src, size_t n)
{
size_t i;
for (i = 0; i < n && src[i] != '\0'; i++)
dest[i] = src[i];
for ( ; i < n; i++)
dest[i] = '\0';
return dest;
}
source:
http://man7.org/linux/man-pages/man3/strncpy.3.html
But what strcpy will do if the source string dont have a room for the null termination:
selvatha$ more test.c
#include<stdio.h>
#include<string.h>
int main() {
char name[7];
strcpy(name,"1234567");
printf("\n %s \n",name);
return 0;
}
SELVATHA-M-V0HE:Unused Desktop selvatha$ gcc test.c
SELVATHA-M-V0HE:Unused Desktop selvatha$ ./a.out
Abort trap: 6
After giving the space for NULL termination:
#include<stdio.h>
#include<string.h>
int main() {
char name[7];
strcpy(name,"1234567");
printf("\n %s \n",name);
return 0;
}
SELVATHA-M-V0HE:Unused Desktop selvatha$ gcc test.c
SELVATHA-M-V0HE:Unused Desktop selvatha$ ./a.out
123456
strchr:
This returns a pointer to the first occurrence of the character c in the string str, or NULL if the character is not found.
Example:
The following example shows the usage of strchr() function.
#include <stdio.h>
#include <string.h>
int main ()
{
const char str[] = "http://www.tutorialspoint.com";
const char ch = '.';
char *ret;
ret = strchr(str, ch);
printf("String after |%c| is - |%s|\n", ch, ret);
return(0);
}
Let us compile and run the above program, this will produce the following result:
String after |.| is - |.tutorialspoint.com|
source:
www.tutorialspoint.com/c_standard_library/c_function_strchr.htm
sprintf
char *itoa(int n)
{
char *retbuf = malloc(25);
if(retbuf == NULL)
return NULL;
sprintf(retbuf, "%d", n);
return retbuf;
}
source: http://www.eskimo.com/~scs/cclass/int/sx5.html
tech2:
%u used for printing the &var
%d itself used for sizeof() operator
tech3:
expr1 << expr2 == expr1 * 2expr2
10 * 32 == 10 << 5 (becuase 32 = 25)
expr1 >> expr2 == expr1 / 2expr2
40 / 4 == 40 >> 2
(becuase 4 = 22)
tech 3:
pointer array to store the character data array
- char name[max][size] == char *ptr[ ] (so char *ptr[ ] can be used to rx datat array in the funcion)
- char *ptr[] == char **ptr (so char **ptr can be used to rx char *ptr[ ]in the funcion)
- so i guess char name[max][size] also can be received via char ** in the function call
example:
http://www.netospgm.blogspot.in/2014/08/pointer-array-and-its-advantage.html
http://publib.boulder.ibm.com/infocenter/macxhelp/v6v81/index.jsp?topic=%2Fcom.ibm.vacpp6m.doc%2Flanguage%2Fref%2Fclrc03example_prog_pointers.htm
tech 4:
- to print the address use %x or %p
example:
#include <stdio.h>
int main ()
{
int var = 20; /* actual variable declaration */
int *ip; /* pointer variable declaration */
ip = &var; /* store address of var in pointer variable*/
printf("Address of var variable: %x\n", &var );
/* address stored in pointer variable */
printf("Address stored in ip variable: %x\n", ip );
/* access the value using the pointer */
printf("Value of *ip variable: %d\n", *ip );
return 0;
}
tech 5:
b & 0xff gets the last byte of b.
root@selvakumar-Lenovo-B460e:/C_pgms/memory# cat last_byte.c
#include<stdio.h>
/* program to mask last one byte of the given number*/
int main()
{
short a=0x0101; // two byte integer in hex format
short b;
printf("\n%d\n",a);
b = a & 0xff; // this mask last 1 byte
printf("\n%d\n",b);
return 0;
}
root@selvakumar-Lenovo-B460e:/C_pgms/memory# gcc last_byte.c
root@selvakumar-Lenovo-B460e:/C_pgms/memory# ./a.out
257
1
root@selvakumar-Lenovo-B460e:/C_pgms/memory#
tech 6;
size of void * and char * is 4
http://www.netospgm.blogspot.in/2014/08/sizeof-void-char.html
tech 7: how do memset on string array:
void *memset(void *str, int c, size_t n)
#include <stdio.h>
#include <string.h>
int main ()
{
char str[50];
strcpy(str,"This is string.h library function");
puts(str);
memset(str,'$',7);
puts(str);
return(0);
}
This is string.h library function
$$$$$$$ string.h library function
Refer:https://www.tutorialspoint.com/c_standard_library/c_function_memset.htm
Techniqure 8:
To define a function
as static, the static keyword has to be included in the signature of the function. It does
not matter in which position the keyword is mentioned, it can be inserted before or after
the return type and other optional keywords, but must be inserted before the function
name
so "static void test()"
or "void static test()".
both are same. but static keyword should be before function name
Reference: https://wr.informatik.uni-hamburg.de/_media/teaching/wintersemester_2013_2014/epc-1314-fasselt-c-keywords-report.pdf
Technique 9:
- int a[10] we can assingn to int *p as p=a . as like normal single interger variable
- we can access the arrary variable using pointer with index operator as p[i]. see second example. so in the function we can receive the array using pointer variable and access that poiter inside function using index operator.
- or we can access the array using pointer as *(p+i)
#include <stdio.h>
int main ()
{ int i;
int AR [] = { 10, 20, 30, 40, 50 };
int *pAR = AR;
clrscr();
printf("\nAR = %p\t &AR[0] = %p\t pAR = %p\n",AR,&AR[0],pAR);
for (i=0;i<5;i++)
printf("*pAR = %d\t AR[%d] = %d\n",*pAR++, i, AR[i]);
return 0;
}
int *pAR = &AR[0];
The values of elements of the array AR [4] may be obtained from its pointer pAR in the following manner:
* pAR = 10
*(pAR+l)= 20
*(pAR+2)= 30
*(pAR+3)= 40
[tselva@bng-junos-d037 /b/tselva/bcopy/bk_copy_needed/copy-needed/work_tips_dir/sample_c_program]$ cat array_pointer.c
#include <stdio.h>
int main ()
{
int i;
int AR [] = { 10, 20, 30, 40, 50 };
int *pAR = AR;
printf("\nAR = %p\t &AR[0] = %p\t pAR = %p\n",AR,&AR[0],pAR);
for (i=0;i<5;i++)
printf("pAR[%d]=%d\n",i,pAR[i]);
for (i=0;i<5;i++)
printf("*pAR = %d\t AR[%d] = %d \n",*pAR++, i, AR[i]);
return 0;
}
[tselva@bng-junos-d037 /b/tselva/bcopy/bk_copy_needed/copy-needed/work_tips_dir/sample_c_program]$ ./a.out
AR = 0xffffc838
&AR[0] = 0xffffc838
pAR = 0xffffc838
pAR[0]=10
pAR[1]=20
pAR[2]=30
pAR[3]=40
pAR[4]=50
*pAR = 10
AR[0] = 10
*pAR = 20
AR[1] = 20
*pAR = 30
AR[2] = 30
*pAR = 40
AR[3] = 40
*pAR = 50
AR[4] = 50
Ref: http://ecomputernotes.com/what-is-c/function-a-pointer/one-dimensional-array-with-pointer
Technique 10: character array
http://control.ucsd.edu/mauricio/courses/mae9/lectures/lecture5.pdf
Technique 11: sizeof vs strlen:
/*
* sizeof_vs_strlen.c -- program shows difference between using sizeof and
* strlen with array and string
*/
#include <stdio.h>
#include <string.h>
int main(void)
{
char msg[] = {'c','h','r','i','s','t','o','p','h','e','r'};
/* Character array */
char name1[] = "christopher"; /* character array */
char *name2 = "christopher"; /* string literal */
printf("sizeof: size of char array msg[] \"%s\" is %d bytes!\n",
msg, sizeof(msg));
printf("strlen: size of char array msg[] \"%s\" is %d bytes!\n",
msg, strlen(msg));
printf("sizeof: size of char array name1[] \"%s\" is %d bytes!\n",
name1, sizeof(name1));
printf("strlen: size of char array name1[] \"%s\" is %d bytes!\n",
name1, strlen(name1));
printf("sizeof: size of string \"%s\" is %d bytes!\n",
name2, sizeof(name2));
printf("strlen: size of string \"%s\" is %d bytes!\n",
name2, strlen(name2));
return 0;
}
Output follows:
sizeof: size of char array msg[] "christopher" is 11 bytes!
strlen: size of char array msg[] "christopher" is 11 bytes!
sizeof: size of char array name1[] "christopher" is 12 bytes!
strlen: size of char array name1[] "christopher" is 11 bytes!
sizeof: size of string "christopher" is 8 bytes!
strlen: size of string "christopher" is 11 bytes!
Ref: http://www.sanfoundry.com/c-tutorials-size-array-using-sizeof-operator-strlen-function/
Technique 12:
This will not work:
char *myfunc1()
{
char temp[] = "string";
return temp;
}
char *myfunc2()
{
char temp[] = {'s', 't', 'r', 'i', 'n', 'g', '\0'};
return temp;
}
int main()
{
puts(myfunc1());
puts(myfunc2());
}
The returned pointer should be to a static buffer (like static char buffer[20];), or to a buffer passed in by the caller function, or to memory obtained using malloc(), but not to a local array.
This will work:
char *myfunc()
{
char *temp = "string";
return temp;
}
int main()
{
puts(someFun());
}
Ref: http://vijayinterviewquestions.blogspot.in/search?q=strcpy
Tehcnique 13:
A to Z ascii value = 65 to 90
a to z ascii value = 97 to 122
int strcmp(const char *str1, const char *str2)
Output:
if Return value < 0 then it indicates str1 is less than str2.
if Return value > 0 then it indicates str2 is less than str1.
if Return value = 0 then it indicates str1 is equal to str2.
Technique 14:
* INADDR_ANY is used when you don't need to bind a socket to a specific IP. When you use this value as the address when calling bind(), the socket accepts connections to all the IPs of the machine.
* This allowed your program to work without knowing the IP address of the machine it was running on, or, in the case of a machine with multiple network interfaces, it allowed your server to receive packets destined to any of the interfaces.
* If you wish to bind your socket to localhost only, the syntax would be my_sockaddress.sin_addr.s_addr = inet_addr("127.0.0.1");, then call bind(my_socket, (SOCKADDR *) &my_sockaddr, ...)
* Example: . For example, suppose that a host has interfaces 0, 1 and 2. If a UDP socket on this host is bound using INADDR_ANY and udp port 8000, then the socket will receive all packets for port 8000 that arrive on interfaces 0, 1, or 2. If a second socket attempts to Bind to port 8000 on interface 1, the Bind will fail since the first socket already ``owns'' that port/interface.
Ref:
https://www.cs.cmu.edu/~srini/15-441/F01.full/www/assignments/P2/htmlsim_split/node18.html
https://stackoverflow.com/questions/16508685/understanding-inaddr-any-for-socket-programming-c
Technique 15:
sprintf vs snprintf
* Both will give the result you want, but snprintf is more generic, and will protect your string from overruns no matter the format string given. In addition, because snprintf(or sprintf for that matter) adds a final \0 , you should make the string buffer one byte bigger, char buff[MAXLEN + 1]
* snprintf ... Writes the results to a character string buffer. (...) will be terminated with a null character, unless buf_size is zero.
Technique 16:
In short: memset require more assembly operations then bzero . You probably shouldn't use bzero , it's not actually standard C, it was a POSIX thing. And note that word "was" - it was deprecated in POSIX.1-2001 and removed in POSIX.1-2008 in deference to memset so you're better off using the standard C
Ref: https://stackoverflow.com/questions/17096990/why-use-bzero-over-memset
Ref:
https://stackoverflow.com/questions/7706936/is-snprintf-always-null-terminating
All in all URL (networks,kernel,system,c)
http://blmrgnn.blogspot.in/2014/06/memory-layout-of-c-program-code-data.html
Techniqure 17:
enum starts with 0 if we dont specify any default value
Technique 18:
Returning the pointer from the function:
Technique 19: deep copy and shallow copy in the C
A shallow copy in this particular context means that you copy
"references" (pointers, whatever) to objects, and the backing store of
these references or pointers is identical, it's the very same object at
the same memory location.
A deep copy, in contrast, means that you copy an entire object
(struct). If it has members that can be copied shallow or deep, you also
make a deep copy of them. Consider the following example:
typedef struct {
char *name;
int value;
} Node;
Node n1, n2, n3;
char name[] = "This is the name";
n1 = (Node){ name, 1337 };
n2 = n1; // Shallow copy, n2.name points to the same string as n1.name
n3.value = n1.value;
n3.name = strdup(n1.name); // Deep copy - n3.name is identical to n1.name
// regarding
// its *contents* only, but it's not anymore the
// same pointer
And Using struct:
We can wrap array in a structure/class and return an
instance of the struct/class. The reason for this
work is, array members of structures are deeply
copied. In below program deep copy happens when
we returned instance is copied in main.
#include <stdio.h>
struct arrWrap {
int arr[100];
};
struct arrWrap fun()
{
struct arrWrap x;
x.arr[0] = 10;
x.arr[1] = 20;
return x;
}
int main()
{
struct arrWrap x = fun();
printf("%d %d", x.arr[0], x.arr[1]);
return 0;
}
Ref:
Technique 20:
How to pass an entire array to a function as an argument?
In the above example, we have passed the address of each array element one by one using a for loop in C. However you can also pass an entire array to a function like this:
Note: The array name itself is the address of first element of that array. For example if array name is arr then you can say that arr is equivalent to the &arr[0].
#include <stdio.h>
void myfuncn( int *var1, int var2)
{
/* The pointer var1 is pointing to the first element of
* the array and the var2 is the size of the array. In the
* loop we are incrementing pointer so that it points to
* the next element of the array on each increment.
*
*/
for(int x=0; x<var2; x++)
{
printf("Value of var_arr[%d] is: %d \n", x, *var1);
/*increment pointer for next element fetch*/
var1++;
}
}
int main()
{
int var_arr[] = {11, 22, 33, 44, 55, 66, 77};
myfuncn(var_arr, 7);
return 0;
}
Ref: https://beginnersbook.com/2014/01/c-passing-array-to-function-example/
Technique 21: convert the string to upper case:
A = 65
a = 97
A-a= 32
Example:
#include <stdio.h>
#include <string.h>
int main() {
char s[100];
int i;
printf("\nEnter a string : ");
gets(s);
for (i = 0; s[i]!='\0'; i++) {
if(s[i] >= 'a' && s[i] <= 'z') {
s[i] = s[i] -32; // s[i] = s[i]+32 to conver into lower case
}
}
printf("\nString in Upper Case = %s", s);
return 0;
}
