Merge two specific columns from a line in C language - c

Question

I want to merge two specific columns from a line in C language. The line is like "hello world hello world". It consists of some words and some white space. The below is my code. In this function, c1 and c2 represent the number of the column, and array key is mergeed string. But it's not good to run.
char *LinetoKey(char *line, int c1, int c2, char key[COLSIZE]){
char *col2 = (char *)malloc(sizeof(char));
while (*line != '\0' && isspace(*line) )
line++;
while(*line != '\0' && c1 != 0){
if(isspace(*line)){
while(*line != '\0' && isspace(*line))
line++;
c1--;
c2--;
}else
line++;
}
while (*line != '\0' && *line != '\n' && (isspace(*line)==0))
*key++ = *line++;
*key = '\0';
while(*line != '\0' && c2 != 0){
if(isspace(*line)){
while(*line != '\0' && isspace(*line))
line++;
c2--;
}else
line++;
}
while (*line != '\0' && *line != '\n' && isspace(*line)==0)
*col2++ = *line++;
*col2 = '\0';
strcat(key,col2);
return key;
}

Answer 1

Here's a possible solution using strtok(). It can handle an arbitrary number of columns (increase the size of buf if necessary), and will still work if the order of the columns is reversed (i.e. c1 > c2). The function returns 1 on success (tokens successfully merged), 0 otherwise.
Note that strtok() modifies its argument - so I have copied input to a temporary buffer, char buf[64].
/*
* Merge space-separated 'tokens' in a string.
* Columns are zero-indexed.
*
* Return: 1 on success, 0 on failure
*/
int merge_cols(char *input, int c1, int c2, char *dest) {
char buf[64];
int col = 0;
char *tok = NULL, *first = NULL, *second = NULL, *tmp = NULL;
if (c1 == c2) {
fprintf(stderr, "Columns can not be the same !");
return 0;
}
if (strlen(input) > sizeof(buf) - 1) return 0;
/*
* strtok() is _destructive_, so copy the input to
* a buffer.
*/
strcpy(buf, input);
tok = strtok(buf, " ");
while (tok) {
if (col == c1 || col == c2) {
if (!first)
first = tok;
else if (first && !second)
second = tok;
}
if (first && second) break;
tok = strtok(NULL, " ");
col++;
}
// In case order of columns is swapped ...
if (c1 > c2) {
tmp = second;
second = first;
first = tmp;
}
if (first) strcpy(dest, first);
if (second) strcat(dest, second);
return first && second;
}
Sample usage:
char *input = "one two three four five six seven eight";
char dest[128];
// The columns can be reversed ...
int merged = merge_cols(input, 7, 1, dest);
if (merged)
puts(dest);
Note also that it is very easy to use different delimiters when using strtok() - so if you wanted to use comma- or tab-separated input instead of spaces, you just change the second argument when calling it.

Answer 2

It is not clear what you're trying to do. If what David Collins suggested is what you're looking for - word concatenation by word index - here's a starting point (demo):
Your function must minimize the number of string traversals. To help this, the code below is using char** instead of char* (sort of "char streams").
The function must be able to count the number of characters the result will have, prior to actual concatenation, in order to be able to allocate the destination string on free store. If catwords is called with null destination, it only counts the length of the result string.
Regarding the actual implementation, you will have to traverse the string word by word and decide whether to copy or skip the word. See the code below for the following functions:
nextword - skips white-spaces until it finds a non-white-space character.
copyword - copies the current word if destination is valid or skips it if not. It returns the number of copied/skipped characters.
#include <ctype.h>
#include <stdlib.h>
void nextword( const char** ps )
{
while ( **ps && isspace( **ps ) )
++*ps;
}
int copyword( char** const pd, const char** ps )
{
// remember the starting point
const char* b = *ps;
// actual copy
if ( pd && *pd ) while ( **ps && !isspace( **ps ) )
*( *pd )++ = *( *ps )++;
// skip the word (no destination)
else while ( **ps && !isspace( **ps ) )
( *ps )++;
// return the length
return *ps - b;
}
int catwords( char* d, const char* s, const int* c )
{
int len = 0;
int iw = 0;
int ic = 0;
const char** ps = &s;
char** pd = &d;
for ( nextword( ps ); **ps && c[ ic ] > -1; nextword( ps ), ++iw )
if ( iw == c[ ic ] )
{
len += copyword( pd, ps );
++ic;
}
else
{
copyword( 0, ps ); // just skip the current word
}
if ( d )
**pd = '\0';
return len;
}
int main()
{
// static buffer test
{
char d[ 1024 ];
int t[] = { 0, 3, -1 };
catwords( d, "Hello world. Hello world!", t );
puts( d );
}
// dynamic buffer test
{
const char* s = "The greatness of a man is not in how much wealth he acquires, but in his integrity and his ability to affect those around him positively.";
int t[] = { 1, 5, 16, -1 };
int dstcharcount = catwords( 0, s, t ) + 1;
char* d = (char*)malloc( dstcharcount * sizeof( char ) );
catwords( d, s, t );
puts( d );
free( d );
}
return 0;
}