国产一区二区三区高清在线观看,国产日产精品一区二区三区四区的观看方式 ,国产精品国内视频

maximum contiguous subsequence sum algorithm 最大子序列��法

huangyi5209 — Tue, 12 Apr 2011 23:13:00 GMT

摘要: // win32console.cpp : 定义控制台应用程序的入口炏V�?/#include "stdafx.h"#include #include using namespace std;/**//* START: Fig02_05.tx... 阅读全文

huangyi5209 2011-04-13 07:13 发表评论

InterlockedExchange �U�程同步

huangyi5209 — Mon, 28 Mar 2011 08:09:00 GMT

    #include
#include <Windows.h>

using namespace std;

volatile LONG lfsSpinLock = 0;
int num = 0;
// lfsSpinLock is a 'long' and when it is '1' it is locked, and '0' is unlocked
#define  ENTER_LFS_LOCK_   while( InterlockedExchange( &lfsSpinLock, 1 ) == 1 ){ Sleep( 10 ); }
#define  EXIT_LFS_LOCK_    InterlockedExchange( &lfsSpinLock, 0 );

void Func1()
{

    //Wait to access the resource.  �{�待资源

    ENTER_LFS_LOCK_;

    for (int i = 0;i < 20; i++)
    {
        num++;
        cout<<num<<endl;
    }

    EXIT_LFS_LOCK_;

}

int _tmain(int argc, _TCHAR* argv[])
{
    HANDLE hThrd[4];

    DWORD dwThrdID[4];
    hThrd[0] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)Func1, NULL, 0, &dwThrdID[0]);
    hThrd[1] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)Func1, NULL, 0, &dwThrdID[1]);
    hThrd[2] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)Func1, NULL, 0, &dwThrdID[2]);
    hThrd[3] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)Func1, NULL, 0, &dwThrdID[3]);

    WaitForMultipleObjects(4, hThrd, TRUE, INFINITE);
    for (int i=0;i<4;i++)
    {
        CloseHandle(hThrd[i]);
    }

    system("pause");
    return 0;
}

huangyi5209 2011-03-28 16:09 发表评论

Thread Synchronization �U�程同步

huangyi5209 — Sun, 06 Mar 2011 01:26:00 GMT

�U�程同步(for Win32)

#include <windows.h>
#include <iostream>

using namespace std;

static int g_n;
CRITICAL_SECTION m_cs;

UINT ThreadOne(LPVOID lParam)
{
    EnterCriticalSection(&m_cs);

    for (int i = 0; i < 10; i++)
    {
        g_n++;
        cout<<"Thread 1:"<<g_n<<"\n";
    }
    LeaveCriticalSection(&m_cs);
    return 0;
}

UINT ThreadTwo(LPVOID lParam)
{
    EnterCriticalSection(&m_cs);

    for (int i = 0; i < 10; i++)
    {
        g_n++;
        cout<<"Thread 2:"<<g_n<<"\n";
    }
    LeaveCriticalSection(&m_cs);
    return 0;
}

int main()
{
    HANDLE hThrd[2];
    DWORD IDThread1,IDThread2;

    InitializeCriticalSection(&m_cs);

    hThrd[0] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadOne, (LPVOID)NULL, 0, &IDThread1);
    hThrd[1] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadTwo, (LPVOID)NULL, 0, &IDThread1);

    WaitForMultipleObjects(2, hThrd, TRUE, INFINITE);
    DeleteCriticalSection(&m_cs);

    system("pause");
    return 0;
}

�U�程同步(for MFC)

#include "win32_mfc.h"
#include <afxmt.h>
#include <iostream>

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

// 唯一的应用程序对�?/span>

CWinApp theApp;

using namespace std;

CCriticalSection c_s;
static int g_C;

UINT ThreadFunction1(LPVOID lParam)
{
    CSingleLock lock(&c_s);

    lock.Lock();

    for (int i = 0; i < 10; i++)
    {
        g_C++;
        cout<<  "Thread 1 : " << g_C << endl;
    }
    lock.Unlock();
    return 0;
}

UINT ThreadFunction2(LPVOID lParam)
{
    CSingleLock lock(&c_s);

    lock.Lock();

    for (int i = 0; i < 10; i++)
    {
        g_C++;
        cout<<  "Thread 2 : " << g_C << endl;
    }
    lock.Unlock();
    return 0;
}

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
    int nRetCode = 0;

    // 初始�?nbsp;MFC �q�在��p�|时显�C�错�?/span>
    if (!AfxWinInit(::GetModuleHandle(NULL), NULL, ::GetCommandLine(), 0))
    {
        // TODO: 更改错误代码以符合您的需�?/span>
        _tprintf(_T("错误: MFC 初始化失败\n"));
        nRetCode = 1;
    }
    else
    {
        // TODO: 在此处�ؓ应用�E�序的行为编写代码�?/span>
        CWinThread *Thread[2];
        HANDLE hand[2];

        Thread[0] = AfxBeginThread(ThreadFunction1, (LPVOID)NULL);
        Thread[1] = AfxBeginThread(ThreadFunction2, (LPVOID)NULL);

        for (int i = 0; i < 2; i++)
            hand[i] = Thread[i]->m_hThread;

        WaitForMultipleObjects(2, hand, TRUE, INFINITE);
    }

    system("pause");
    return nRetCode;
}

huangyi5209 2011-03-06 09:26 发表评论

huangyi5209 — Sat, 05 Mar 2011 00:30:00 GMT

自动重置事�g内核对象

#include "stdafx.h"
#include <windows.h>
#include <iostream>

using namespace std;

DWORD WINAPI Tf()
{
    cout<<"thread instantiated "<<endl;

    HANDLE hEvent = OpenEvent(EVENT_ALL_ACCESS, FALSE, __T("MyEvent"));
    if (!hEvent)
        return -1;

    for (char counter = 0; counter < 2; counter++) //char
    {
        WaitForSingleObject(hEvent, INFINITE);
        cout<<"Got The Single"<<endl;
    }
    CloseHandle(hEvent);
    cout<<"End of the Thread"<<endl;
    return 0;
}

int main(){
    //    Create an Auto Reset Event which automatically reset to
    //    Non Signalled state after being signalled
    HANDLE hEvent = CreateEvent(NULL, FALSE, FALSE, __T("MyEvent"));
    if (!hEvent)
        return -1;

    DWORD Id;
    HANDLE hThrd = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)Tf, 0, 0, &Id);
    while(!hThrd)
    {
         CloseHandle(hThrd);
         return -1;
    }
    // Wait for a while before continuing.
    Sleep(1000);

    for (char counter = 0; counter < 2; counter++)
    {
        // Signal the event
        SetEvent(hEvent);
        // wait for some time before giving another signal
        Sleep(2000);
    }
    // Wait for the Thread to Die
    WaitForSingleObject(hThrd, INFINITE);
    CloseHandle(hThrd);
    CloseHandle(hEvent);

    cout<<"End of Main .."<<endl;

    system("pause");
    return 0;
}

手动重置事�g内核对象

DWORD WINAPI Tf()
{
    cout<<"thread instantiated "<<endl;

    HANDLE hEvent = OpenEvent(EVENT_ALL_ACCESS, FALSE, __T("MyEvent"));
    if (!hEvent)
        return -1;

    for (char counter = 0; counter < 2; counter++) //char
    {
        WaitForSingleObject(hEvent, INFINITE);
        // We need to reset the event since the event is manual reset
        //    event
        ResetEvent(hEvent);
        cout<<"Got The Single"<<endl;
    }
    CloseHandle(hEvent);
    cout<<"End of the Thread"<<endl;
    return 0;
}

int main(){
    //    Create an Manual Reset Event where events must be reset
    //    manually to non signalled state
    HANDLE hEvent = CreateEvent(NULL, TRUE, FALSE, __T("MyEvent"));
    if (!hEvent)
        return -1;

    DWORD Id;
    HANDLE hThrd = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)Tf, 0, 0, &Id);
    while(!hThrd)
    {
         CloseHandle(hThrd);
         return -1;
    }
    // Wait for a while before continuing.
    Sleep(1000);

    for (char counter = 0; counter < 2; counter++)
    {
        // Signal the event
        SetEvent(hEvent);
        // wait for some time before giving another signal
        Sleep(2000);
    }
    // Wait for the Thread to Die
    WaitForSingleObject(hThrd, INFINITE);
    CloseHandle(hThrd);
    CloseHandle(hEvent);

    cout<<"End of Main .."<<endl;

    system("pause");
    return 0;
}

huangyi5209 2011-03-05 08:30 发表评论

ASCII �?UNICODE

huangyi5209 — Fri, 04 Mar 2011 23:57:00 GMT

wchar_t *ascii_to_unicode(const char *resource)
{
    const char* sp;
    wchar_t* result, *rp;
     unsigned length = strlen(resource) + 1;
     if (!resource)
         return NULL;

     result = (wchar_t*)malloc(length * sizeof(wchar_t));
     if (result)
     {
         for (sp = resource, rp = result; *sp; sp++, rp++)
             *rp = *sp;
         *rp = 0;
     }

     return result;
}

int main(){
    char ch[] = "C:\\data\\\\test230.ext";
    wchar_t* wchr = ascii_to_unicode(ch);

    free(wchr);
    system("pause");
    return 0;
}

huangyi5209 2011-03-05 07:57 发表评论

区分C++的指针和引用

huangyi5209 — Mon, 24 Jan 2011 12:29:00 GMT

Pointers and references look different enough (pointers use the “*” and “->” operators, references use “.“), but they seem to do similar things. Both pointers and references let you refer to other objects indirectly. How, then, do you decide when to use one and not the other?

First, recognize that there is no such thing as a null reference. A reference must always refer to some object. As a result, if you have a variable whose purpose is to refer to another object, but it is possible that there might not be an object to refer to, you should make the variable a pointer, because then you can set it to null. On the other hand, if the variable must alwaysrefer to an object, i.e., if your design does not allow for the possibility that the variable is null, you should probably make the variable a reference.

“But wait,” you wonder, “what about underhandedness like this?”

char *pc = 0; // set pointer to null
char& rc = *pc; // make reference refer to
// dereferenced null pointer

Well, this is evil, pure and simple. The results are undefined (compilers can generate output to do anything they like), and people who write this kind of code should be shunned until they agree to cease and desist. If you have to worry about things like this in your software, you’re probably best off avoiding references entirely. Either that or finding a better class of programmers to work with. We’ll henceforth ignore the possibility that a reference can be “null.”

Because a reference must refer to an object, C++ requires that references be initialized:

string& rs; // error! References must

// be initialized
string s("xyzzy");
string& rs = s; // okay, rs refers to s

Pointers are subject to no such restriction:

string *ps; // uninitialized pointer:
// valid but risky

The fact that there is no such thing as a null reference implies that it can be more efficient to use references than to use pointers. That’s because there’s no need to test the validity of a reference before using it:

void printDouble(const double& rd)

{
cout << rd; // no need to test rd; it
} // must refer to a double

Pointers, on the other hand, should generally be tested against null:

void printDouble(const double *pd)
{
if (pd) { // check for null pointer
cout << *pd;
}
}

Another important difference between pointers and references is that pointers may be reassigned to refer to different objects. A reference, however, always refers to the object with which it is initialized:

string s1("Nancy");
string s2("Clancy");
string& rs = s1; // rs refers to s1
string *ps = &s1; // ps points to s1
rs = s2; // rs still refers to s1,
// but s1's value is now
// "Clancy"
ps = &s2; // ps now points to s2;
// s1 is unchanged

In general, you should use a pointer whenever you need to take into account the possibility that there’s nothing to refer to (in which case you can set the pointer to null) or whenever you need to be able to refer to different things at different times (in which case you can change where the pointer points). You should use a reference whenever you know there will always be an object to refer to and you also know that once you’re referring to that object, you’ll never want to refer to anything else.

References, then, are the feature of choice when you know you have something to refer to, when you’ll never want to refer to anything else, and when implementing operators whose syntactic requirements make the use of pointers undesirable. In all other cases, stick with pointers.

huangyi5209 2011-01-24 20:29 发表评论

huangyi5209 — Mon, 24 Jan 2011 12:26:00 GMT

Introduction

If you are reading this article, you probably wonder what callback functions are. This article explains what callback functions are, what are they good for, why you should use them, and so forth. However, before learning what callback functions are, you must be familiar with function pointers. If you aren't, consult a C/C++ book or consider reading the following:

The Syntax of C and C++ Function Pointers
Pointers to member functions
Declaring, Assigning, and Using Function Pointers

What Is a Callback Function?

The simple answer to this first question is that a callback function is a function that is called through a function pointer. If you pass the pointer (address) of a function as an argument to another, when that pointer is used to call the function it points to it is said that a call back is made.

Why Should You Use Callback Functions?

Because they uncouple the caller from the callee. The caller doesn't care who the callee is; all it knows is that there is a callee with a certain prototype and probably some restriction (for instance, the returned value can be int, but certain values have certain meanings).

If you are wondering how is that useful in practice, imagine that you want to write a library that provides implementation for sorting algorithms (yes, that is pretty classic), such as bubble sort, shell short, shake sort, quick sort, and others. The catch is that you don't want to embed the sorting logic (which of two elements goes first in an array) into your functions, making your library more general to use. You want the client to be responsible to that kind of logic. Or, you want it to be used for various data types (ints, floats, strings, and so on). So, how do you do it? You use function pointers and make callbacks.

A callback can be used for notifications. For instance, you need to set a timer in your application. Each time the timer expires, your application must be notified. But, the implementer of the time'rs mechanism doesn't know anything about your application. It only wants a pointer to a function with a given prototype, and in using that pointer it makes a callback, notifying your application about the event that has occurred. Indeed, the SetTimer() WinAPI uses a callback function to notify that the timer has expired (and, in case there is no callback function provided, it posts a message to the application's queue).

Post a comment
Email Article
Print Article
Share Articles

Another example from WinAPI functions that use callback mechanism is EnumWindow(), which enumerates all the top-level windows on the screen. EnumWindow() iterates over the top-level windows, calling an application-provided function for each window, passing the handler of the window. If the callee returns a value, the iteration continues; otherwise, it stops. EnumWindows() just doesn't care where the callee is and what it does with the handler it passes over. It is only interested in the return value, because based on that it continues its execution or not.

However, callback functions are inherited from C. Thus, in C++, they should be only used for interfacing C code and existing callback interfaces. Except for these situations, you should use virtual methods or functors, not callback functions.

A Simple Implementation Example

Now, follow the example that can be found in the attached files. I have created a dynamic linked library called sort.dll. It exports a type called CompareFunction:

typedef int (__stdcall *CompareFunction)(const byte*, const byte*);

which will be the type of your callback functions. It also exports two methods, called Bubblesort() and Quicksort(), which have the same prototype but provide different behavior by implementing the sorting algorithms with the same name.

void DLLDIR __stdcall Bubblesort(byte* array,
                                 int size,
                                 int elem_size,
                                 CompareFunction cmpFunc);

void DLLDIR __stdcall Quicksort(byte* array,
                                int size,
                                int elem_size,
                                CompareFunction cmpFunc);

These two functions take the following parameters:

byte* array: a pointer to an array of elements (doesn't matter of which type)
int size: the number of elements in the array
int elem_size: the size, in bytes, of an element of the array
CompareFunction cmpFunc: a pointer to a callback function with the prototype listed above

The implementation of these two functions performs a sorting of the array. But, each time there is a need to decide which of two elements goes first, a callback is made to the function whose address was passed as an argument. For the library writer, it doesn't matter where that function is implemented, or how it is implemented. All that matters it is that it takes the address of two elements (that are the two be compared) and it returns one of the following values (this is a contract between the library developers and its clients):

-1: if the first element is lesser and/or should go before the second element (in a sorted array)
0: if the two elements are equal and/or their relative position doesn't matter (each one can go before the other in a sorted array)
1: if the first element is greater and/or should go after the second element (in a sorted array)

With this contract explicitly stated, the implementation of the Bubblesort() function is this (for Quicksort(), which a little bit more complicated, see the attached files).

void DLLDIR __stdcall Bubblesort(byte* array,
                                 int size,
                                 int elem_size,
                                 CompareFunction cmpFunc)
{
   for(int i=0; i < size; i++)
   {
      for(int j=0; j < size-1; j++)
      {
         // make the callback to the comparison function
         if(1 == (*cmpFunc)(array+j*elem_size,
                  array+(j+1)*elem_size))
         {
            // the two compared elements must be interchanged
            byte* temp = new byte[elem_size];
            memcpy(temp, array+j*elem_size, elem_size);
            memcpy(array+j*elem_size,
                   array+(j+1)*elem_size,
                   elem_size);
            memcpy(array+(j+1)*elem_size, temp, elem_size);
            delete [] temp;
         }
      }
   }
}

Note: Because the implementation uses memcpy(), these library functions should not be used for types other than POD (Plain-Old-Data).

On the client side, there must be a callback function whose address is to be passed to the Bubblesort() function. As a simple example, I have written a function that compares two integer values and one that compares two strings:

int __stdcall CompareInts(const byte* velem1, const byte* velem2)
{
   int elem1 = *(int*)velem1;
   int elem2 = *(int*)velem2;

   if(elem1 < elem2)
      return -1;
   if(elem1 > elem2)
      return 1;

   return 0;
}

int __stdcall CompareStrings(const byte* velem1, const byte* velem2)
{
   const char* elem1 = (char*)velem1;
   const char* elem2 = (char*)velem2;

   return strcmp(elem1, elem2);
}

To put all these to a test, I have written this short program. It passes an array with five elements to Bubblesort() or Quicksort() along with the pointer to the callback functions.

int main(int argc, char* argv[])
{
   int i;
   int array[] = {5432, 4321, 3210, 2109, 1098};

   cout << "Before sorting ints with Bubblesort\n";
   for(i=0; i < 5; i++)
      cout << array[i] << '\n';

   Bubblesort((byte*)array, 5, sizeof(array[0]), &CompareInts);

   cout << "After the sorting\n";
   for(i=0; i < 5; i++)
      cout << array[i] << '\n';

   const char str[5][10] = {"estella",
                            "danielle",
                            "crissy",
                            "bo",
                            "angie"};

   cout << "Before sorting strings with Quicksort\n";
   for(i=0; i < 5; i++)
      cout << str[i] << '\n';

   Quicksort((byte*)str, 5, 10, &CompareStrings);

   cout << "After the sorting\n";
   for(i=0; i < 5; i++)
      cout << str[i] << '\n';

   return 0;
}

If I decide that I want the sorting to be done descending (with the biggest element first), all I have to do is to change the callback function code, or provide another that implements the desired logic.

Calling Conventions

In the above code, you can see the word __stdcall in the function's prototype. Because it starts with a double underscore, it is, of course, a compiler-specific extension, more exactly a Microsoft-specific one. Any compiler that supports development of Win32-based applications must support this or an equivalent one. A function that is marked with __stdcall uses the standard calling convention so named because all Win32 API functions (except the few that take variable arguments) use it. Functions that follow the standard calling convention remove the parameters from the stack before they return to the caller. This is the standard convention for Pascal. But in C/C++, the calling convention is that the caller cleans up the stack instead of the called function. To enforce that a function uses the C/C++ calling convention, __cdeclmust be used. Variable argument functions use the C/C++ calling convention.

Windows adopted the standard calling convention (Pascal convention) because it reduces the size of the code. This was very important in the early days of Windows, when it ran on systems with 640 KB RAM.

If you don't like the word __stdcall, you can use the CALLBACK macro, defined in windef.h, as

#define CALLBACK    __stdcall

#define CALLBACK    PASCAL

where PASCAL is #defined as __stdcall.

You can read more about calling convention here: Calling Convetions in Microsoft Visual C++.

C++ Methods as Callback Functions

Because you probably write in C++, you want your callback function a method of a class. But, if you try this:

class CCallbackTester
{
public:
   int CALLBACK CompareInts(const byte* velem1, const byte* velem2);
};

Bubblesort((byte*)array, 5, sizeof(array[0]),
           &CCallbackTester::CompareInts);

with a MS compiler, you get this compilation error:

error C2664: 'Bubblesort' : cannot convert parameter 4 from 'int (__stdcall CCallbackTester::*)(const unsigned char *,const unsigned char *)' to 'int (__stdcall *)(const unsigned char *,const unsigned char *)' There is no context in which this conversion is possible

That happens because non-static member functions have an additional parameter, pointer this (see thisFAQ for more).

That obliges you to make the member function static. If that's not acceptable, you can use several techniques to overcome that. Check the following links to learn more.

How to Implement Callbacks in C and C++
C++ Callback Demo
Callbacks in C++ Using Template Functors

Notices

The attached files contain two projects. SortingDLL is a Win32 DLL project. The sort.dll output library exports the two sorting functions, Bubblesort() and Quicksort(). The second project, SortDemo, is a Win32 Console Application that demonstrates how to use the sort.dll library. The output directory for both projects is Shared directory, where the following files can be found: sort.h, sort.dll, sort.lib, and SortDemo.exe.

Further References

C++ OO Callback Technique
Function Pointers to Non-Static Object Methods
Pointers and References

About the Author

Marius Bancila is a Microsoft MVP for VC++. He works as a software developer for a Norwegian-based company. He is mainly focused on building desktop applications with MFC and VC#. He keeps a blog at www.mariusbancila.ro/blog, focused on Windows programming. He is the co-founder of codexpert.ro, a community for Romanian C++/VC++ programmers.

Downloads

callbacks.zip

huangyi5209 2011-01-24 20:26 发表评论