C / C++ / MFC

includeh10 wrote:

I think there should be other ways for faster adding items.

pandit84 wrote:

If a process creats a threads and then detaches that thread.

pandit84 wrote:

Now If I kill my process then in this case will my thread run upto its completion ?

UINT AdditionalThread(LPVOID p)
{
 // do stuff (assume that this takes 10 seconds)
 return 0;
}

int main()
{
  _beginthread(AdditionalThread, 0, 0);
  //do stuff (assume this takes 3 seconds)
  //write code to wait for AdditionalThread to complete, or it will be killed
  return 0;
}

Rajesh R Subramanian wrote:

If it is a native application, then every other thread created within the application will be killed abruptly when the main thread comes to a halt.

Stephen Hewitt wrote:

See here[^] for a more complete explaination.

goldenrose9 wrote:

BYTE *pByte = new BYTE[64];

Stefan63 wrote:

If you want to, you can replace the system's operator new and delete with your own implementations. These could then store additional information, such as the number of elements being allocated...

class Buffer {
	public:
		Buffer(unsigned nSize) : m_pBuffer(NULL), m_nLength(nSize) {
			if (nSize > 0) {
				m_pBuffer = new BYTE[nSize];
				if (m_pBuffer == NULL) {
					m_nLength = 0;
					//you ran out of memory, do something
				}
			}
		}
		~Buffer() {
			if (m_pBuffer != NULL) {
				delete []m_pBuffer;
			}
		}
		unsigned GetLength() {
			return m_nLength;
		}
		BYTE &operator[](unsigned nIndex) {
			if (nIndex >= m_nLength) {
				//error somehow
			}
			return m_pBuffer[nIndex];
		}
		BYTE *operator*() {
			return m_pBuffer;
		}

	private:
		BYTE *m_pBuffer;
		unsigned nLength;
};

Buffer bufData(64);
strcpy(*bufData, "hello world"); //the operator*() can be used to get a pointer to the data
//print the length
printf("The valid range is 0-%u\n", bufData.GetLength() - 1); //remember indices start at 0 and go to n-1
printf("The 2nd character is \'%c\'\n", bufData[1]); //Again, indices start at 0 making the 2nd element index 1
//The buffer automatically cleans up its memory when it goes out of scope