Skip to main content

Bitwise operators with pointers

0 likes • Nov 18, 2022 • 0 views
C
Loading...

More C Posts

signal() example

0 likes • Nov 19, 2022 • 0 views
C
#include <stdio.h>
#include <assert.h>
#include <signal.h>
void myHandler(int iSig) {
printf("In myHandler with argument %d\n", iSig);
}
int main() {
void( * pfRet)(int) = signal(SIGINT, myHandler);
assert(pfRet != SIG_ERR);
printf("Entering an infinite loop\n");
while (1) {
printf(".");
}
return 0; // use CTRL+\ to exit
}

inner fork() variables

0 likes • Nov 19, 2022 • 2 views
C
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int glbvar = 6;
int main() {
int locvar = 88;
pid_t pid;
printf("Before fork()\n");
if ((pid = fork()) == 0) {
/* child */
glbvar++;
locvar++;
} else if (pid > 0) {
/* parent */
sleep(2);
} else
perror("fork error");
printf("pid=%d, glbvar=%d, locvar=%d\n", getpid(), glbvar, locvar);
return 0;
} /* end main */

socketTCPServer.c

0 likes • Aug 5, 2023 • 0 views
C
// compile: gcc socketTCPServer.c -o socketTCPServer.out
// usage : ./socketTCPServer.out port
// Server
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
int main(int argc, char *argv[]){
int listenfd = 0, connfd = 0, cli_size, portno;
struct sockaddr_in serv_addr, cli_addr;
char sendBuff[1025];
if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
printf("socket error\n");
exit(EXIT_FAILURE);
}
memset(&serv_addr, '0', sizeof(serv_addr));
memset(sendBuff, '0', sizeof(sendBuff));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
portno = atoi(argv[1]);
serv_addr.sin_port = htons(portno);
const int on = 1;
setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
if(bind(listenfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1){
printf("bind error\n");
exit(EXIT_FAILURE);
}
if(listen(listenfd, 5) == -1){
printf("listen error\n");
exit(EXIT_FAILURE);
}
while(1){
cli_size = sizeof(cli_addr);
if((connfd = accept(listenfd, (struct sockaddr*)&cli_addr, &cli_size)) == -1){
printf("accept error\n");
exit(EXIT_FAILURE);
}
strcpy(sendBuff, "Server Message: SUCCESS\n");
write(connfd, sendBuff, strlen(sendBuff));
close(connfd);
sleep(1);
}
return 0;
}

Heavy Coin

0 likes • Oct 4, 2023 • 2 views
C
#include <stdio.h>
#include <stdlib.h>
// give an array of identical coins (ints), represented by 1's and one 2
// we can find the heavy coin (2) by summing the contents of the thirds
int sum_subarr(int arr[], int l, int r){
int sum = 0;
for(int i = l; i <= r; i++)
{
sum += arr[i];
}
return sum;
}
int heavy_coin(int arr[], int l, int r){
if(r == l)
{
return r;
}
int midl = l + (r - l)/3;
int midr = r - (r - l)/3;
int lw = sum_subarr(arr, l, midl);
int mw = sum_subarr(arr, midl + 1, midr);
if ( lw > mw )
{
return heavy_coin(arr, l, midl);
}
else if ( lw < mw )
{
return heavy_coin(arr, midl + 1, midr);
}
else
{
return heavy_coin(arr, midr + 1, r);
}
}
int main(int argc, char *argv[])
{
int arr[] = {1,1,1,1,2,1,1,1,1};
int l = 0;
int r = 8;
int res = -1;
res = heavy_coin(arr, l, r);
printf("Hevy coin is at index: %d\n", res);
return EXIT_SUCCESS;
}

replaceString

0 likes • Nov 14, 2021 • 0 views
C
//===============replaceString.c===============
#include "replaceString.h"
//Normally I'd make a replaceStringMalloc to return a malloced string or a replaceStringMut to change the original string, but I'm not satisfied with those function names so it's best just to do to = (char*)malloc(replaceStringLength(from, replace, replacement)); replaceString(to, from, replace, replacement);
//If this was c++, I'd have no problem just overloading replaceString
//Returns the length of the resulting string (minus the null char)
size_t replaceStringLength(const char* from, const char* replace, const char* replacement){
size_t fromLength = strlen(from);
size_t replaceLength = strlen(replace);
size_t replacementLength = strlen(replacement);
size_t fromEndIt = 0;
size_t toLength = 0;
while(fromEndIt < fromLength){
int replaceIt = 0;
while(replaceIt < replaceLength && (fromEndIt+replaceIt) < fromLength && from[fromEndIt + replaceIt] == replace[replaceIt]){
++replaceIt;
}
if(replaceIt == replaceLength){
//Update from buffer iterator positions
toLength += (fromEndIt + replacementLength);
from += (fromEndIt + replaceLength);
fromEndIt = 0;
continue;
}
++fromEndIt;
}
toLength += fromEndIt;
return toLength;
}
//Baller replaceString by Leif Messinger
//Needs null terminated from, replace, and replacement strings as well as a large block of memory to store the result.
void replaceString(char* to, const char* from, const char* replace, const char* replacement){
size_t fromLength = strlen(from);
size_t replaceLength = strlen(replace);
size_t replacementLength = strlen(replacement);
size_t fromEndIt = 0;
while(fromEndIt < fromLength){
int replaceIt = 0;
while(replaceIt < replaceLength && (fromEndIt+replaceIt) < fromLength && from[fromEndIt + replaceIt] == replace[replaceIt]){
++replaceIt;
}
if(replaceIt == replaceLength){
//Copy the string before the matched bit
memcpyToAndShiftPointers(to, from, fromEndIt);
//Copy the replacement too
memcpyToAndShiftPointer(to, replacement, replacementLength);
//Update from buffer iterator positions
from += replaceLength;
fromEndIt = 0;
continue; //I don't want this thing to get incremented again
}
++fromEndIt;
}
//Copy the rest of the unmatched string
memcpyToAndShiftPointer(to, from, fromEndIt);
to[0] = '\0'; //Should work
}
//===============replaceString.h===============
#ifndef REPLACE_STRING_H
#define REPLACE_STRING_H
#include <string.h>
#define memcpyToAndShiftPointer(to,from,n); memcpy((to),(from),(n)); (to) += (n);
#define memcpyToAndShiftPointers(to,from,n); memcpy((to),(from),(n)); (to) += (n); (from) += n;
//Normally I'd make a replaceStringMalloc to return a malloced string or a replaceStringMut to change the original string, but I'm not satisfied with those function names so it's best just to do to = (char*)malloc(replaceStringLength(from, replace, replacement)); replaceString(to, from, replace, replacement);
//If this was c++, I'd have no problem just overloading replaceString
//Returns the length of the resulting string (minus the null char)
size_t replaceStringLength(const char* from, const char* replace, const char* replacement);
//Baller replaceString by Leif Messinger
//Needs null terminated from, replace, and replacement strings as well as a large block of memory to store the result.
void replaceString(char* to, const char* from, const char* replace, const char* replacement);
#endif
//===============replaceStringMain.c===============
#include <stdio.h>
#include <stdlib.h>
#include "replaceString.h"
#define BUFFER_SIZE (1<<21) //About a mebibyte
//There could be matches between buffers, so make sure the buffer size you set it to is good enough for your application. Basically as big as your input.
//Replaces strings from sdtin, then outputs it to stdout
//./a.out [[replace], [replacement]]...
int main(int argc, char** argv){
char* buffer1 = (char*) malloc(BUFFER_SIZE);
char* buffer2 = (char*) malloc(BUFFER_SIZE);
if(buffer1 == NULL || buffer2 == NULL){
perror("You need a couple MBs of ram my boy");
return 1;
}
while(!feof(stdin)){
fread(buffer1, BUFFER_SIZE, 1, stdin);
char* activeBuffer = buffer1;
char* inactiveBuffer = buffer2;
char* tmp;
for(size_t i = 1; (i + 1) < argc; i += 2){
//puts(activeBuffer);
replaceString(inactiveBuffer, activeBuffer, argv[i], argv[i+1]);
//Swap buffers
tmp = activeBuffer;
activeBuffer = inactiveBuffer;
inactiveBuffer = tmp;
}
fputs(activeBuffer, stdout);
}
free(buffer1);
free(buffer2);
return 0;
}

Fast inverse square root

0 likes • Nov 19, 2022 • 0 views
C
// The following code is the fast inverse square root implementation from Quake III Arena
// this code has been stripped of C preprocessor directives, but includes the exact original comment text
float Q_rsqrt( float number )
{
long i;
float x2, y;
const float threehalfs = 1.5F;
x2 = number * 0.5F;
y = number;
i = * ( long * ) &y; // evil floating point bit level hacking
i = 0x5f3759df - ( i >> 1 ); // what the fuck?
y = * ( float * ) &i;
y = y * ( threehalfs - ( x2 * y * y ) ); // 1st iteration
// y = y * ( threehalfs - ( x2 * y * y ) ); // 2nd iteration, this can be removed
return y;
}