ATL / WTL / STL

wchar_t names[ COMMON_ARRAY_SIZE ][ MAX_NAME_SIZE ];
Set_Pointer( &names[0][0] );

void Set_Pointer( wchar_t *new_pointer)
{
    wchar_t *mp_local_pointer;
    mp_local_pointer = new_pointer;
    wcscpy_s( one,   MAX_NAME_SIZE, mp_local_pointer    ); // OK
    wcscpy_s( two,   MAX_NAME_SIZE, mp_local_pointer[1] ); // cannot convert
    ...}

mp_local_pointer[1]

bkelly13 wrote:

I get back to where I started.

// allocate an array of items
wchar_t savedItems[COMMON_ARRAY_SIZE][MAX_NAME_SIZE];
// create a local pointer to the original array that points to the first item
wchar_t* localPointer;
localPointer = new_pointer;
for (int i = 0; i < COMMON_ARRAY_SIZE; ++i)
{
    wcscpy_s(savedItems[i], MAX_NAME_SIZE, localPointer);
    localPointer += MAX_NAME_SIZE; // point to the next item which is MAX_NAME_SIZE characters on
}

The issue is that you are trying to copy data from a multi-dimensional array using a single dimension pointer; and given the structure of your original array you have no other choice.

struct dataArray
{
    wchar_t item[ MAX_NAME_SIZE ];
} names[COMMON_ARRAY_SIZE];
// names is an array of structures
Set_Pointer(names);


void Set_Pointer(dataArray* new_pointer)
{
    dataArray* mp_local_pointer;
    mp_local_pointer = new_pointer;
    wcscpy_s(one, MAX_NAME_SIZE, dataArray[0].item); // OK
    wcscpy_s(two, MAX_NAME_SIZE, dataArray[1].item); // OK
    ...
}

#include "stdafx.h"

const unsigned int COMMON_ARRAY_SIZE = 10;
const unsigned int MAX_NAME_SIZE = 34;

struct st2_names
{
    wchar_t names[ COMMON_ARRAY_SIZE ] [ MAX_NAME_SIZE ];
};

void Set_Pointer_2( st2_names *new_pointer );

int _tmain(int argc, _TCHAR* argv[])
{
    st2_names names_2;

    wcscpy_s( names_2.names[0]  , MAX_NAME_SIZE, L"PITCH" );
    wcscpy_s( names_2.names[1]  , MAX_NAME_SIZE, L"ROLL" );
    wcscpy_s( names_2.names[2]  , MAX_NAME_SIZE, L"YAW" );
    wcscpy_s( names_2.names[3]  , MAX_NAME_SIZE, L"VELOCITY" );

    Set_Pointer_2( &names_2 );
    return 0;
}

void Set_Pointer_2( st2_names *new_pointer )
{
    st2_names *mp_names_2;
    mp_names_2 = new_pointer;

    wchar_t t1[MAX_NAME_SIZE];
    wchar_t t2[MAX_NAME_SIZE];
    wchar_t t3[MAX_NAME_SIZE];
    wchar_t t4[MAX_NAME_SIZE];

    wcscpy_s( t1, MAX_NAME_SIZE, mp_names_2->names[0] );
    wcscpy_s( t2, MAX_NAME_SIZE, mp_names_2->names[1] );
    wcscpy_s( t3, MAX_NAME_SIZE, mp_names_2->names[2] );
    wcscpy_s( t4, MAX_NAME_SIZE, mp_names_2->names[3] );
}

wchar_t names[ x ] [ y ];

bkelly13 wrote:

It does seem to me that you are saying

bkelly13 wrote:

I apologize for being rather slow

// define the structure for holding the item labels
struct st2_names
{
    wchar_t names[ COMMON_ARRAY_SIZE ] [ MAX_NAME_SIZE ];
};

// C_Configuration_Manager reads some data, adjusts it
// and copies the items into the data structure fields
int C_Configuration_Manager(st2_names *new_pointer)
{
    // copy the various items (read from a text file in reality)
    // to the individual items of the array
    wcscpy_s(new_pointer->names[0], MAX_NAME_SIZE, L"PITCH" );
    wcscpy_s(new_pointer->names[1], MAX_NAME_SIZE, L"ROLL" );
    wcscpy_s(new_pointer->names[2], MAX_NAME_SIZE, L"YAW" );
    wcscpy_s(new_pointer->names[3], MAX_NAME_SIZE, L"VELOCITY" );
    // ...
    
    return 0;
}
 
int C_AR2_Messages(st2_names *dataPointer)
{
    // The core code, C_AR2_Messages, hands the pointer over to C_Configuration_Manager.
    // That code reads a text file and changes the names adding a prefix to them.
    C_Configuration_Manager(dataPointer);	// pass the pointer to C_Configuration_Manager
    
    // When C_AR2_Messages resumes control, it queries another application (a vendor app) 
    // to acquire more information about the parameter.
    CallOtherFunction(dataPointer); // and so on
    
    // other processing as required

    return 0;
}

int wmain(int argc, wchar_t* argv[])
{
    // declare the structure, and clear it out for good measure
    st2_names dataNames;
    memset(&dataNames, 0, sizeof dataNames);
    
    C_AR2_Messages(&dataNames);	// pass the pointer to C_AR2_Messages
    
    return 0;
}

const wchar_t  prefix[ SIZE_OF ] = L"S01_";
void Set_Pointer( wchar_t (*new_pointer)[COUNT_OF][SIZE_OF] )
{
   foo_names = new_pointer;
   swprintf_s( (*foo_names)[0],SIZE_OF, L"%s%s", prefix, c0 );
}

unsigned int __stdcall  Start_Server_As_Thread( void * p_void_pointer )
{
    C_Server_Thread    *mp_C_Server_Thread = NULL;
    WCHAR m_log_file_text[ MAX_LOG_STRING_LENGTH ];


      mp_C_Server_Thread =  new C_Server_Thread( p_void_pointer );

        // Call the main method of the class.  When this method returns,
        // the thread exits.
      mp_C_Server_Thread->Main_Thread_Loop();

      delete mp_C_Server_Thread;
      mp_C_Server_Thread = NULL;

        // We are all done.  End this thread.
    _endthreadex( 0 );

    return 0;
}

class C_Server_Thread
{...}

class C_TCP_API_Server
{...}

bkelly13 wrote:

Does that help narrow the field?

bkelly13 wrote:

I was thinking of std::string

#if defined(UNICODE)
typedef	std::wstring	STRING;
#else
typedef	std::string	STRING;
#endif

bkelly13 wrote:

The TCP/IP will make it difficult to port