Strings

[D Technodude]

I was wondering if you can include a period in a string? If not then what variable can you inlcude a period in?

[Disch]

Er... of course.

#include <iostream>
#include <string>
using namespace std;

int main()
{
  string foo = "This is a string with a period in it.  <- see?";

  cout << foo;

  return 0;
}

[D Technodude]

Sorry, had another bug interferring with my string var.
Thanks...again.

[SHUNEYTZ]

//stateMachine.cpp : Defines the entry point for the console application.
//


#include <string.h>

#define VALID 1
#define INVALID 0

#define D_A 0
#define D_B 1

#define ARR_SIZE 25

typedef struct{
char cmdArr[ARR_SIZE];
bool AorB;
}cmd_s;

typedef struct{
char cmdArr[ARR_SIZE];
int size;
}cmd3_s;


/* Global Variables */
cmd_s Cmd;
cmd3_s Cmd3;


void fillArr(char destArr[], const char sourceArr[], const int size)
{
memset(destArr, 0, ARR_SIZE);
memcpy(destArr, sourceArr, size);
}

bool isCmd(const char * cmd_t, const int size)
{
if(strncmp(Cmd.cmdArr, cmd_t, size) == 0)
{
return 1;
}
return 0;
}

int checkCmd(bool drction, char * cmd_t, int size, int *statePtr, int dest_state)
{
if(Cmd.AorB == drction)
{
if(isCmd(cmd_t, size))
{
*statePtr = dest_state;
return VALID;
}
}
*statePtr = 1;
return INVALID;
}

void saveCmd3(const char sourceArr[], const int size)
{
fillArr(Cmd3.cmdArr, sourceArr, size);
Cmd3.size = size - 1; //don't count the '/0'
}

int checkState3(int *statePtr)
{
int status = (checkCmd(D_A, "LIST", sizeof("LIST"),statePtr, 4));

saveCmd3("LIST", sizeof("LIST"));

// other possible commands ...

if(status == INVALID)
{
status = (checkCmd(D_A, "EXIT ", sizeof("EXIT "),statePtr, 5));
}

return status;
}

int getCmdLen()
{
int i=0;
int cnt=0;

for(i=0; i<ARR_SIZE; i++)
{
if(Cmd.cmdArr[i] != '\0')
cnt++;
}

return cnt;
}

int checkCh(char ch)
{
if((ch >='a') && (ch <='z'))
return VALID;

if((ch >='0') && (ch <='9'))
return VALID;

return INVALID;

}

int checkState4(int *statePtr)
{
int cmdSize = getCmdLen();
int cmd3Sise = Cmd3.size;
int SecondIdx = cmdSize - cmd3Sise;
int i;

*statePtr = 1;

if(cmdSize < cmd3Sise*2 + 2)
return INVALID;

if(strncmp(&Cmd.cmdArr[0], Cmd3.cmdArr, cmd3Sise) != 0)
return INVALID;

if(strncmp(&Cmd.cmdArr[SecondIdx], Cmd3.cmdArr, cmd3Sise) != 0)
return INVALID;

// check the msg
for(i = cmd3Sise+1; i<= SecondIdx-2 ; i++ )
{
if(checkCh(Cmd.cmdArr[i]) == INVALID)
return INVALID;
}

*statePtr = 3;
return VALID;

}

int handleCmd()
{
static int stat_state = 1;

switch(stat_state)
{
case 1:
return (checkCmd(D_A, "OPEN_CONNECTION", sizeof("OPEN_CONNECTION"),&stat_state, 2));
case 2:
return (checkCmd(D_B, "OPEN_CONNECTION_ACKED", sizeof("OPEN_CONNECTION_ACKED"),&stat_state, 3));
case 3:
return (checkState3(&stat_state));
case 4:
return (checkState4(&stat_state));
case 5:
return (checkCmd(D_B, "EXIT_ACKED", sizeof("EXIT_ACKED"),&stat_state, 1));
default: return INVALID;
}
}

int _tmain(int argc, _TCHAR* argv[])
{
// init
memset(&Cmd, 0, sizeof(Cmd) );
memset(&Cmd3, 0, sizeof(Cmd3));

Cmd.AorB = D_A;
fillArr(Cmd.cmdArr, "OPEN_CONNECTION", sizeof("OPEN_CONNECTION"));
handleCmd();

Cmd.AorB = D_B;
fillArr(Cmd.cmdArr, "OPEN_CONNECTION_ACKED", sizeof("OPEN_CONNECTION_ACKED"));
handleCmd();

Cmd.AorB = D_A;
fillArr(Cmd.cmdArr, "LIST", sizeof("LIST"));
handleCmd();

Cmd.AorB = D_B;
fillArr(Cmd.cmdArr, "LIST 6575 LIST", sizeof("LIST 6575 LIST"));
handleCmd();


return 0;
}