ATL / WTL / STL

// Option 1
m_send_status = WSASend(
            m_client_socket,
            &mp_lpwsabuf[ *mp_send_array_index ], // use addressof operator
            1,        // one buffer for now
            NULL,     // I will add this later
            NULL,     // no flags
            m_overlapped[ *mp_send_array_index ],
            NULL );   // no completion routine

// Option 2
m_send_status = WSASend(
            m_client_socket,
            mp_lpwsabuf + *mp_send_array_index, // add offset to pointer
            1,        // one buffer for now
            NULL,     // I will add this later
            NULL,     // no flags
            m_overlapped[ *mp_send_array_index ],
            NULL );   // no completion routine

bkelly13 wrote:

It is a bit complicated but the end application will handle a stream of 12 megabits/second and must extract parameters real time and pass them on.

bkelly13 wrote:

Thank for so much for your time and mostly for your patience.

wchar_t parm3[Buffsize1024];
if(Function(parm1, parm2, parm3)==0){
// ...

WCHAR*  some_names[] = { { "name1" }, { "name2" }, ... };

// or using the pointer type

PWSTR some_names[] = { { "name1" }, { "name2" }, ... };

WCHAR m_test_1_[COMMON_ARRAY_SIZE][MAX_PARAMETER_NAME_LENGTH];

wcscpy_s( m_test_1[0], MAX_PARAMETER_NAME_LENGTH, L"[0] 1234" 
wcscpy_s( m_test_1[1], MAX_PARAMETER_NAME_LENGTH, L"[1] 1234" 
wcscpy_s( m_test_1[2], MAX_PARAMETER_NAME_LENGTH, L"[2] 1234" 
wstring test_5 = m_test_1[0];
wstring test_6 = m_test_1[1];
wstring test_7 = m_test_1[2];

WCHAR  *mp_common_parameter_names [COMMON_ARRAY_SIZE][MAX_PARAMETER_NAME_LENGTH];

Void C_Configuration_Manager::Set_common_names_Pointer(
WCHAR *new_pointer[ COMMON_ARRAY_SIZE][MAX_PARAMETER_NAME_LENGTH] )
{ mp_common_parameter_names = new_pointer; }

Quote:

1>e:\visual|studio\ar2_message_app_v11.1\ar2_message_app\c_configuration_manager.cpp(120)
: error C2440: ‘=’ : cannot convert from ‘WCHAR 8[][34] TO ‘wchar *[18][34]’
1> There are no conversions to array types, although there are conversions to references or pointers to arrays

WCHAR  * (mp_common_parameter_names [COMMON_ARRAY_SIZE][MAX_PARAMETER_NAME_LENGTH] );

// declare the pointer in the class
WCHAR* names;

// the function to set it
void Set_Local_Pointer(WCHAR* new_pointer)
{
    mp_local_pointer = new_pointer;
}

// code to create the array and pass it to the class
WCHAR names[ STRING_COUNT ][ SIZE_OF_STRING ];
// copy the strings to each SIZE_OF_STRING element of the array
wcscpy_s(names[0], L"StringZero");
wcscpy_s(names[1], L"StringOne");
wcscpy_s(names[2], L"StringTwo");
// etc
Set_Local_Pointer(names[0])
// Note that you must not modify or otherwise change the content of names after this point or the data used by the class will be corrupt. 

BlahBlah class
{
    WCHAR mpNames[STRING_COUNT][SIZE_OF_STRING];
//
void Set_Local_Pointer(WCHAR new_pointer)
{
    memcpy(mp_local_pointer, new_pointer, STRING_COUNT * SIZE_OF_STRING);
}
// or
void Set_Local_Pointer(WCHAR pLabel, int index)
{
    memcpy(mp_local_pointer[index], pLabel, SIZE_OF_STRING);
}

#include "stdafx.h"

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

void Set_Pointer( wchar_t new_pointer[ COMMON_ARRAY_SIZE ][ MAX_NAME_SIZE ])
{
    wchar_t local_pointer[ COMMON_ARRAY_SIZE ][ MAX_NAME_SIZE ];
    wchar_t one[ MAX_NAME_SIZE ];
    wchar_t two[ MAX_NAME_SIZE ];

    local_pointer = new_pointer;  // line 12 will not compile

    wcscpy_s( one, MAX_NAME_SIZE, local_pointer[0]  ); // will work
    wcscpy_s( two, MAX_NAME_SIZE, new_pointer[1]  );   // line 15
};

int _tmain(int argc, _TCHAR* argv[])
{
    wchar_t names[ COMMON_ARRAY_SIZE ][ MAX_NAME_SIZE ];

    wcscpy_s( names[ 0 ], MAX_NAME_SIZE, L"[0] 123" );
    wcscpy_s( names[ 1 ], MAX_NAME_SIZE, L"[1] 123" );
    wcscpy_s( names[ 2 ], MAX_NAME_SIZE, L"[2] 123" );
    wcscpy_s( names[ 3 ], MAX_NAME_SIZE, L"[3] 123" );

    Set_Pointer( names );
    return 0;  }

Quote:

Error 1 error C2440: '=' : cannot convert from 'wchar_t [][34]' to 'wchar_t [10][34]'

//  don't use pointer as a name for an array
    wchar_t local_array[ COMMON_ARRAY_SIZE ][ MAX_NAME_SIZE ];

//  copy elements one at a time
    wcscpy_s(local_array[0], MAX_NAME_SIZE, new_pointer[0]); // etc

//  or copy the entire array
    memcpy(local_array, new_pointer, COMMON_ARRAY_SIZE * MAX_NAME_SIZE);   // as previously suggested

wchar_t* local_pointer; // this is a pointer

local_pointer = new_pointer; //  local_pointer now holds the address of the original data

void Set_Pointer( wchar_t *new_pointer)
{
    wchar_t *local_pointer;
    wchar_t one[   MAX_NAME_SIZE ];
    wchar_t two[   MAX_NAME_SIZE ];
    wchar_t three[ MAX_NAME_SIZE ];
    wchar_t four[  MAX_NAME_SIZE ];

    local_pointer = new_pointer;

    wcscpy_s( one,   MAX_NAME_SIZE, local_pointer    ); // OK
    wcscpy_s( two,   MAX_NAME_SIZE, local_pointer[1] ); // cannot convert
    wcscpy_s( three, MAX_NAME_SIZE, local_pointer[2] ); // cannot convert
    wcscpy_s( four,  MAX_NAME_SIZE, local_pointer[3] ); // cannot convert
};

Quote:

Error 1 error C2664: 'errno_t wcscpy_s(wchar_t *,rsize_t,const wchar_t *)' : cannot convert parameter 3 from 'wchar_t' to 'const wchar_t *'

wchar_t  some_array[ x ] [ y ];

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.