C / C++ / MFC

#include <iostream>
#include <fstream>
#include <vector>
using namespace std;

template < typename T1, typename T2 >
void printvector(T1& fout, const std::vector < T2 >& V)
{
    if (V.empty()) fout << "EMPTY\n";
    else {
        for (size_t x = 0; x != V.size() - 1; ++x)
        {
           fout << V[x] << ", ";
        }
        fout << V[V.size() - 1] << '\n';
    }
}


int main()
{
  vector <size_t> sub {46,47,48};

  printvector(cout, sub);
  fstream foofile("foo.txt", ios::out);
  if (foofile)
  {
    printvector(foofile, sub);
  }
}

46, 47, 48

#include <iostream>
#include <fstream>
#include <vector>
using namespace std;

template <typename T>
ostream & operator<< (ostream & os, const vector <T> & v)
{
  if ( v.empty() ) os << "EMPTY\n";
  else
  {
    for (size_t n = 0; n != v.size() - 1; ++n)
    {
      os << v[n] << ", ";
    }
    os << v.back() << '\n';
  }
  return os;
}

int main()
{
  vector <size_t> sub {46,47,48};

  cout << sub;
  fstream foofile("foo.txt", ios::out);
  if (foofile)
  {
    foofile << sub;
  }
}

struct landmarktype {
    std::string fiducial{};
    std::string name{};
    Matrix location{}; //=Initialize(3,1);
    std::vector <size_t> subtractions{};
};

vector <landmarktype> NewLandmarks;

class Matrix {
    private:
        double * M;
        size_t ROWS, COLUMNS;
    public:
        Matrix(): M(NEW double[1]), ROWS(1), COLUMNS(1) {} // default constructor
        Matrix(size_t R, size_t C): M(NEW double[R * C]), ROWS(R), COLUMNS(C) {} // constructor
        ~Matrix() {delete[] M;}; // destructor
        Matrix(const Matrix & m): M(NEW double[m.ROWS * m.COLUMNS]), // copy constructor
            ROWS(m.ROWS), COLUMNS(m.COLUMNS) {
            for (size_t i = 0; i != (ROWS * COLUMNS); i++) M[i] = m.M[i];
            }

    double & operator()(const size_t R,
        const size_t C); //output a value from (row,col) cell
    double operator()(const size_t R,
        const size_t C) const;

    [[nodiscard]] size_t rows() const { return ROWS; }
    [[nodiscard]] size_t cols() const { return COLUMNS; }

    void set(const size_t R, const size_t C) {
        double* newMat = NEW double[R*C];
        delete[] M;
        M = newMat;
        ROWS = R;
        COLUMNS = C;
    }

    void clear()
    {
        double* newMat = DBG_NEW double[0];
        delete[] M;
        M = newMat;
        ROWS = 0;
        COLUMNS = 0;
    }

    void print(std::fstream & ) const;
}


void Matrix::print(fstream & fout) const {
    size_t r, c;
    for (c = 0; c != COLUMNS; ++c)
        for (r = 0; r != ROWS; ++r)
        {
            fout << setiosflags(ios::fixed) << std::setprecision(outputprecision) << std::setw(22) << M[r * COLUMNS + c];
            if ((r*COLUMNS+c) != (ROWS*COLUMNS - 1)) fout << ", ";
        }
}

Gopi Nath wrote:

Can we do this in C++ in the application startup

ReleaseSemaphore( hSemaphore, 1, (LPLONG)&dwSCount );
wsprintf( szBuffer, "Thread %x is done with semaphore. Its count was %ld.", GetCurrentThreadId(), dwSemCount );
SendMessage( hWnd, WM_USER, 0, (LPARAM)szBuffer );