C / C++ / MFC

yogeshs wrote:

bcoz of not deleting pointer it crashes sometimes

#include <iostream> // for std::cerr
#include <new> // for the definition of std::bad_alloc
class MyData {
private:
   A* myobj;
public:
   MyData(int size = 100) {
      try { // make sure to catch bad_alloc!
         myobj = new A[size];
      }
      catch (std::bad__alloc& ba) {
         myobj = 0; // now at least this MyData object is properly initialized
         throw ba; // rethrow - your application should catch this and deal with it appropriately!
      }
   }
   ~MyData() { //destructor
      if (myobj != 0) { // just added for clarity, this is actually redundant
         delete [] myobj; // be sure to use delete [], not just delete
      }
   }
};

int main() {
   int error = 0;
   MyData *arrayData = 0;
   try { // make sure to catch exceptions!
      arrayData = new MyData[200]; // this will call the constructor MyData::MyData() for each element
   }
   catch (std::bad_alloc& ba) {
      std::cerr << "Error - bad alloc: " << ba.what() << std::endl;
      error = 1;
   }
   if (arrayData != 0) {
      // do something
      // ...
      // now clean up
      delete [] arrayData; // this will also call MyData::~MyData() for all 200 elements!
      arrayData = 0;
   }
   return error;
}

class A {
   //...
   A() {
      var = TempVar; // or whatever
   }
   //...
};

#include <iostream> // for std::cerr
#include <new> // for the definition of std::bad_alloc

// declare an allocator interface
class MyAllocatorHelper {
public:
   virtual void* allocate() const = 0;
}

// declare a global accessor to the allocator interface
class MyArrayAllocator {
public:
   static MyAllocatorHelper const* p;
   static void* makeArray() {
      return p ? p->allocate() : 0;
   }
}

// data array wrapper class
class MyData {
private:
   A* myobj;
public:
   MyData();
   ~MyData() { //destructor
      if (myobj != 0) { // just added for clarity, this is actually redundant
         delete [] myobj; // be sure to use delete [], not just delete
      }
   }
};

// implement the MyData constructor:
MyData::MyData() {
   try { // make sure to catch bad_alloc!
      myobj = MyArrayAllocator::makeArray();
   }
   catch (std::bad__alloc& ba) {
      myobj = 0; // now at least this MyData object is properly initialized
      throw ba; // rethrow - your application should catch this and deal with it appropriately!
   }
}

// declare an actual implementation for that allocator interface
class MyDataArray : public MyAllocatorHelper {
private:
   MyData* the_array;
   std::size_t current_index;
   void* allocate() const; // MyDataArray implements the allocator interface!
public:
   MyDataArray(std::size_t size);
   MyData* get(std::size_t index);
};

// and now the implementation
MyDataArray::MyDataArray(std::size_t size) : the_array(0), current_index(0) {
   try { // make sure to catch exceptions!
      the_array = new MyData[size];
   }
   catch (std::bad_alloc& ba) {
      if (the_array != 0) {
         // error occurred during element allocation
         // the array elelmnts aren't fully usable
         // - you could check the current_index to see at what point the error occurred
         // anyway, clean up to make sure nothing bad happens:
         delete[] the_array;
         the_array = 0;
      }
      throw(ba); // rethrow to main()
   }
}

void* MyDataArray::allocate() const {
   A* result = 0;
   std::size_t alloc_size = 0;
   // now determine the actual size for the array with index current_index
   // ...
   // increment index counter
   ++current_index;
   // allocate array
   try {
      result = new A[alloc_size];
   }
   catch (std::bad_alloc& ba) {
      throw(ba);
   }
   return result;
}

int main() {
   int error = 0;
   MyDataArray* arrayData = 0;
   try { // make sure to catch exceptions!
      arrayData = new MyDataArray(200);
   }
   catch (std::bad_alloc& ba) {
      std::cerr << "Error - bad alloc: " << ba.what() << std::endl;
      error = 1;
   }
   if (arrayData != 0) {
      // do something
      // ...
      // now clean up
      delete arrayData;
      arrayData = 0;
   }
   return error;
}

i52camam wrote:

Okay, I'm sorry. WriteAllText is a function of the namespace System.IO:

#include "stdafx.h"
#include <fstream>

using namespace std;

int main() {
    fstream file;
    file.open("filename.txt");
    string foo = "here's some text";
    file << foo;
    file.close();
    return 0;
}

void Guardar::OnBnClickedGuardar()
{
    SaveToFile();
}

void Guardar::SaveToFile()
{
	CString nombre=_T("\D:\Write_File.dat");
	CFile cfile;
	cfile.Open(nombre , CFile::modeCreate | CFile::modeReadWrite);
	char pbufWrite[100];
	memset(pbufWrite, 'a', sizeof(pbufWrite));
	cfile.Write(pbufWrite, 100);         
	cfile.Flush();
}

i52camam wrote:

CString nombre=_T("\D:\Write_File.dat");

CString nombre=_T("D:\\Write_File.dat");

cfile.Flush();

cfile.Close();

Falconapollo wrote:

And I don't how to deal with the cell format, say I want the background of cells to be red, and the font color to be green and so on.

DavidCrow wrote:

Packet of?

Code-o-mat wrote:

I could try creating a bitmap, drawing the lines onto it, trying to render an
alpha channel somehow and then alphablend this onto the original image but i
wouldn't like to do this because it sounds a lot like wasting resources and not
even sure how to render the alpha.