i wanna be a programmer

curiosity and peace, day by day

nameless string objects

Posted by Krzysztof Szynter w dniu 1 kwietnia 2009

// include string, iostream // GLUPI TEN WORDPRESS

int main()
{
	string name = "John McCain";
	string spaces = string(20, ' ');
	cout << "name: " << name << spaces << "X" << endl;
	cout << "name: " << name + spaces << "X" << endl;

	cout << "name: " << name << string(20, ' ') << "X" << endl;
	cout << "name: " << name + string(20, ' ') << "X" << endl;

	return 0;
}

Output:

name: John McCain                    X
name: John McCain                    X
name: John McCain                    X
name: John McCain                    X

Posted in programowanie | Leave a Comment »

konwersja konstruktorowa

Posted by Krzysztof Szynter w dniu 27 marca 2009

Kompilator posiada scisle okreslone reguly dotyczace konwersji typow. Jest to temat dosc szeroki i zahaczajacy o przeciazanie funkcji oraz reguly dopasowywania typow argumentow aktualnych do parametrow formalnych funkcji. Na samym koncu tych regul, jest uzycie konwersji operatorowych okreslonych przez programiste. Z tematem tym zwiazane sa przeksztalcenia konstruktorowe.

Przyklad uzycia konwersji konstruktorowej.

#include "stdafx.h"
#include 

using namespace std;

class myChar
{
	public:
		char znak;

		myChar() : znak('a') {}
		myChar(char c) : znak(c) { cout << "wywolane myChar: " << endl; }
};

class myInt
{
	public:
		int x;

		myInt() : x(0) {}
		myInt(int a) : x(a) { cout << "wywolane myint(int);" << endl; }
		myInt(char c) : x(int(c)) { cout << "wywolane myint(char);" << endl; }
		myInt(double d) : x(int(d)) { cout << "wywolane myint(double);" << endl; }
};

void fun1(myInt mi)
{
	cout << "myInt: " << mi.x << endl;
}

int main()
{
	int a = 10;
	fun1(a);

	char c = 'k';
	fun1(c);

	double d = 3.14;
	fun1(d);
}

Wynik uruchomienia:
wywolane myint(int);
myInt: 10
wywolane myint(char);
myInt: 107
wywolane myint(double);
myInt: 3

Posted in programowanie | Leave a Comment »

zmiana wlasciwosci wielu obiektow na raz

Posted by Krzysztof Szynter w dniu 25 marca 2009

Jedna forma, pięć labelek i cztery buttony.. Cztery sposoby na zmianę właściwości .Text pięciu labelek za jednym kliknięciem button’a.

using System;
using System.Linq;
using System.Windows.Forms;

// foreach (Object obj in this.Controls) ??

namespace multipleLabelsTextChange
{
	public partial class Form1 : Form
	{
		public Form1()
		{
			InitializeComponent();
		}

		private void setLabelsText1()
		{
			var labelGroup1 = new[] { label1, label2, label3 };
			foreach (var label in labelGroup1)
				label.Text = "button2";

			var labelGroup2 = new[] { label4, label5 };
			foreach (var label in labelGroup2)
				label.Text = "nothing";
		}

		private void setLabelsText2()
		{
			foreach (var label in this.Controls.Cast().Where(l => l.Name.StartsWith("label")))
				label.Text = "wow!";
		}

		private void setLabelsText3()
		{
			foreach (var label in this.Controls.Cast().OfType())
				label.Text = "OfType!";
		}

		private void button1_Click(object sender, EventArgs e)
		{
			label1.Text = label2.Text = label3.Text = label4.Text = label5.Text = "button1";
		}

		private void button2_Click(object sender, EventArgs e)
		{
			setLabelsText1();
		}

		private void button3_Click(object sender, EventArgs e)
		{
			setLabelsText2();
		}

		private void button4_Click(object sender, EventArgs e)
		{
			setLabelsText3();
		}
	}
}

Projekt do pobrania i uruchomienia SRC :: ms_visual_2008_formaLabelkiDelegaty_2009.03.26.rar

Posted in programowanie | Leave a Comment »

przeciazanie operatorow

Posted by Krzysztof Szynter w dniu 24 marca 2009

Trzy proste klasy oraz sposób wykorzystania przeciążonych operatorów do (formatowanego) wyświetlania obiektów przy pomocy cout.

// main.cpp : main project file.

#include "stdafx.h"

using namespace std;

// *********** //
// KLASA myInt //
// *********** //

class myInt
{
    friend ostream& operator<x = a;
}

int myInt::getX(void)
{
    return this->x;
}

// ************* //
// KLASA myPoint //
// ************* //

class myPoint
{
    friend ostream& operator<x = a; this->y = b;
}

int myPoint::getX(void)
{
    return this->x;
}

int myPoint::getY(void)
{
    return this->y;
}

// **************** //
// KLASA myCurrency //
// **************** //

class myCurrency
{
    friend ostream& operator<val = val;
}

float myCurrency::getVal()
{
    return this->val;
}

// ****************************** //
// FUNKCJE przeciazajace operator //
// ****************************** //

ostream & operator <<(ostream & output, myInt & i)
{
    output << "[" << i.getX() << "]";
    return output;
}

ostream & operator <<(ostream & output, myPoint & p)
{
    output << "(" << p.getX() << "," << p.getY() << ")";
    return output;
}

ostream & operator <<(ostream & output, myCurrency & c)
{
    output << c.getVal() << " PLN";
    return output;
}

// ************** //
// PROGRAM glowny //
// ************** //

int main()
{
    myInt i1(5), i2(10);

    cout << "liczba i1: " << i1 << endl;
    cout << "liczba i2: " << i2 << endl;

    myPoint p1(0,0), p2(2,4);

    cout << "\npunkt p1: " << p1 << endl;
    cout << "punkt p2: "     << p2 << endl;

    myCurrency pln1(100), pln2(1534);

    cout << "\npunkt pln1: " << pln1 << endl;
    cout << "punkt pln2: "   << pln2 << endl;

    system("PAUSE");
    return 0;
}

Posted in programowanie | Otagowane: | Leave a Comment »

delegaty zbiorowe

Posted by Krzysztof Szynter w dniu 23 marca 2009

Sposob uzycia delegatow pojedynczo oraz zbiorowo.

using System;

namespace delegaty
{
	public class classA		// klasa deklarujaca delegata
	{
		public delegate void myDelegate();
	}

	public class classB		// klasa z metodami statycznymi
	{
		public static void staticFunc1() { Console.WriteLine("classB.staticFunc1"); }
		public static void staticFunc2() { Console.WriteLine("classB.staticFunc2"); }
		public static void staticFunc3() { Console.WriteLine("classB.staticFunc3"); }
	}

	public class classC		// klasa z metodami NIEstatycznymi
	{
		public void nonStaticFunc1() { Console.WriteLine("classC.nonStaticFunc1"); }
		public void nonStaticFunc2() { Console.WriteLine("classC.nonStaticFunc2"); }
		public void nonStaticFunc3() { Console.WriteLine("classC.nonStaticFunc3"); }
	}

	public class classD		// klasa z delegatem statycznym
	{
		public static readonly classA.myDelegate myStaticDel1 = new classA.myDelegate(classD.staticFunc1);
		public static void staticFunc1() { Console.WriteLine("classD.staticFunc1"); }
	}

	public class classE		// klasa z wlasciwoscia zwracajaca delegata
	{
		public static void staticFunc1() { Console.WriteLine("classE.staticFunc1"); }
		public static classA.myDelegate myPropDel1
		{
			get { return new classA.myDelegate(staticFunc1); }
		}
	}

	class Program
	{
		static void Main(string[] args)
		{
			// ******************
			// **** SPOSOB ZEROWY
			// ******************

			// **** wywolanie metod statycznych
			Console.WriteLine("Wywolanie metod statycznych, dostep przez nazwe klasy: \n");
			classB.staticFunc1(); classB.staticFunc2(); classB.staticFunc3();

			// **** wywolanie metod NIEstatycznych
			Console.WriteLine("\nWywolanie metod NIEstatycznych, dostep przez egzemplarz klasy: \n");
			classC obj1 = new classC();
			obj1.nonStaticFunc1(); obj1.nonStaticFunc2(); obj1.nonStaticFunc3(); 
		
			// ********************
			// **** SPOSOB PIERWSZY
			// ********************
		
			// **** delegaty pojedyncze, zawieraja metody statyczne
			Console.WriteLine("\nWywolanie metod statycznych poprzez delegaty pojedyncze: \n");
			classA.myDelegate myDel1 = new classA.myDelegate(classB.staticFunc1);
			classA.myDelegate myDel2 = new classA.myDelegate(classB.staticFunc2);
			classA.myDelegate myDel3 = new classA.myDelegate(classB.staticFunc3);
			myDel1(); myDel2(); myDel3();

			// **** delegat zbiorowy, zawiera metody statyczne
			Console.WriteLine("\nWywolanie metod statycznych poprzez delegata zbiorowego: \n");
			classA.myDelegate myDel123;	myDel123 = myDel1 + myDel2 + myDel3;
			myDel123();

			// *****************
			// **** SPOSOB DRUGI
			// *****************

			// **** delegaty pojedyncze, zawieraja metody NIEstatyczne
			Console.WriteLine("\nWywolanie metod NIEstatycznych poprzez delegaty pojedyncze: \n");
			classA.myDelegate myDel4 = new classA.myDelegate(obj1.nonStaticFunc1);
			classA.myDelegate myDel5 = new classA.myDelegate(obj1.nonStaticFunc1);
			classA.myDelegate myDel6 = new classA.myDelegate(obj1.nonStaticFunc1);
			myDel4(); myDel5(); myDel6();

			// **** delegat zbiorowy, zawiera metody NIEstatyczne
			Console.WriteLine("\nWywolanie metod NIEstatycznych poprzez delegata zbiorowego: \n");
			classA.myDelegate myDel456; myDel456 = myDel4 + myDel5 + myDel6;
			myDel456();

			// ******************
			// **** SPOSOB TRZECI
			// ******************
			
			// **** delegat statyczny, zawiera metoda statyczna
			Console.WriteLine("\nWywolanie metody statycznej poprzez delegata statycznego: \n");
			classD.myStaticDel1();

			// plusy: jest gotowy, nie trzeba tworzyc egzemplarza delegata
			// wady:  istnieje nawet jesli sie go nie wywola

			// *******************
			// **** SPOSOB CZWARTY
			// *******************

			// **** delegat jako wlasciwosc klasy, (bedzie) zawiera(l) metode statyczna (w momencie dostepu)
			Console.WriteLine("\nWywolanie metody statycznej poprzez wlasciwosc klasy: \n");
			classE.myPropDel1();

			// plusy: delegat tworzony w dopiero momencie dostepu do wlasciwosci,
			//	      tworzeniem zajmuje sie kod w klasie a nie w programie

			Console.Read();
		}
	}
}

Posted in programowanie | Leave a Comment »

sprawdzanie typów

Posted by Krzysztof Szynter w dniu 19 marca 2009

Sposoby sprawdzania oraz wyświetlania typów obiektów.

using System;

namespace mojaPrzestrzen
{
  class Program
  { 
    public class classA { }   

    static void Main(string[] args)
    {   
      Console.WriteLine("typ int to typ: {0}", typeof(int));
      Console.WriteLine("klasa classA to typ: {0}", typeof(classA));

      // BLAD :: nie wolno sprawdzac typu
      // obiektow niezainicjowanych
      // int X; classA Y;

      int X = 10; 
      classA Y = new classA();

      Console.WriteLine("\nobiekt X to typ: {0}", X.GetType());
      Console.WriteLine("obiekt Y to typ: {0}", Y.GetType());

      Type tX = typeof(int);
      Type tY = typeof(classA);

      Console.WriteLine("\nobiekt X to typ: {0}", tX);
      Console.WriteLine("obiekt Y to typ: {0}", tY);

      var a = 10; 
      var str = "jakis_lancuch";

      Console.WriteLine("\ntyp obiektu a to: {0}", a.GetType());
      Console.WriteLine("typ obiektu str to: {0}", str.GetType());

      Console.ReadLine();
    }   
  } 
}

źródło :: MSDN::typeof

Posted in programowanie | Leave a Comment »

pomiar czasu

Posted by Krzysztof Szynter w dniu 19 marca 2009

Pomiar czasu iteracji wartości obiektu trzema sposobami: iteracji bezpośredniej, poprzez mechanizm refleksji oraz poprzez delegata.

using System;
using System.Diagnostics;
using System.Reflection;

namespace ConsoleApplication1
{
  public delegate void NoArgDelegate();

  public class MyTestObject
  {
    private int _counter = 0;
    public void Increment()
    {
      _counter++;
    }

    public NoArgDelegate GetIncDelegate()
    {
      return new NoArgDelegate(Increment);
    }

    public void wyswietlWyniki(string tytul, long ticks, TimeSpan ts)
    {
      string timeElapsed = String.Format("{0:00},{1:00} sekund", ts.Seconds, ts.Milliseconds);
      Console.WriteLine("{0}", tytul);
      Console.WriteLine("Czas metoda systemowa: {0:00} milisekund", ticks);
      Console.WriteLine("Czas klasš Stopwach: {0}\n", timeElapsed);
    }
  }

  class Program
  {
    static void Main(string[] args)
    {
      long ticks;
      Stopwatch myStopWatch = new Stopwatch();
      MyTestObject obj = new MyTestObject();

      // #1 - BEZPOŚREDNIA INKREMENTACJA
      myStopWatch.Start();
      ticks = Environment.TickCount;
      for (int i = 0; i < 5000000; i++) { obj.Increment(); }
      myStopWatch.Stop();

      obj.wyswietlWyniki("Inkrementacja bezposrednia", Environment.TickCount - ticks, myStopWatch.Elapsed);

      // ustawienie liczników przed kolejnym pomiarem
      myStopWatch.Reset();
      obj = new MyTestObject();
      MethodInfo mi = typeof(MyTestObject).GetMethod("Increment");

      // #2 - UZYCIE MECHANIZMU REFLEKSJI
      myStopWatch.Start();
      ticks = Environment.TickCount;
      for (int i = 0; i < 5000000; i++) { mi.Invoke(obj, null); }
      myStopWatch.Stop();

      obj.wyswietlWyniki("Uzycie mechanizmu refleksji", Environment.TickCount - ticks, myStopWatch.Elapsed);

      // ustawienie liczników przed kolejnym pomiarem
      myStopWatch.Reset();
      obj = new MyTestObject();
      mi = typeof(MyTestObject).GetMethod("GetIncDelegate");
      NoArgDelegate del = (NoArgDelegate)mi.Invoke(obj, null);

      // #3 - UZYCIE DELEGATA
      myStopWatch.Start();
      ticks = Environment.TickCount;
      for (int i = 0; i < 5000000; i++) { del(); }
      myStopWatch.Stop();

      obj.wyswietlWyniki("Uzycie delegata", Environment.TickCount - ticks, myStopWatch.Elapsed);

      Console.Read();
    }
  }
}

źródło :: MSDN::system.diagnostics.stopwatch.aspx

Posted in programowanie | Leave a Comment »

linki, strony, materiały do nauki..

Posted by Krzysztof Szynter w dniu 13 marca 2009

c#

blogi, porady, sztuczki, kruczki
http://dotnetdud.blogspot.com/
http://dotnetperls.com/

manuale, referencje
http://msdn.microsoft.com/en-us/library/default.aspx

artykuły, tutoriale
http://www.codeproject.com/

c++

książki
http://jcatki.no-ip.org:8080/fncpp/Resources#books

manuale, referencje
http://cplusplus.com/

Posted in programowanie | Leave a Comment »