#include <reg51.h>
void DummyDelay();
void main(void){
char c = 0x00;
while(1){
P1 = c++;
DummyDelay();
}
}
void DummyDelay(){
unsigned char i, j;
for(i = 0; i < 0xFF; i++){
for(j = 0; j < 0xFF; j++){
}
}
}
#include <iostream>
using namespace std;
const int LEN = 10;
int A_int[LEN];
int* ptA_int;
char A_char[LEN];
char* ptA_char;
int main()
{
cout << "Pointer and Array" << endl;
int i;
char c;
for (i = 0, c = 'a'; i < LEN; i++, c++){
A_int[i] = i;
A_char[i] = c;
cout << A_int[i] << "/" << A_char[i] << " ";
}
cout << endl;
ptA_int = A_int;
ptA_char = A_char;
for (i = 0; i < LEN; i++){
cout << *(ptA_int + i) << " ";
}
cout << endl;
for (i = 0; i < LEN; i++){
cout << *(ptA_char + i) << " ";
}
cout << endl;
return 0;
}
#include <iostream>
#include <cstdlib>
using namespace std;
void InsertionSort(int* ar, int len);
const int LENGTH = 10;
int data[LENGTH];
int main()
{
//Prepare data
for (int i = 0; i < 10; i++) {
data[i] = rand() % 100;
}
cout << "data before Insertion Sort:" << endl;
for (int i = 0; i < 10; i++)
cout << data[i] << " ";
cout << endl << endl;
InsertionSort(data, LENGTH);
cout << endl << "data before Insertion Sort:" << endl;
for (int i = 0; i < 10; i++)
cout << data[i] << " ";
cout << endl;
return 0;
}
void InsertionSort(int* ar, int len){
int cur, j;
for (int i = 1; i < len; i++) {
cur = ar[i];
j = i - 1;
while ((j >= 0) && (ar[j] > cur)) {
ar[j + 1] = ar[j];
j--;
}
ar[j + 1] = cur;
for (int ii = 0; ii < 10; ii++)
cout << ar[ii] << " ";
cout << endl;
}
}
private: System::Void button1_Click(System::Object^ sender, System::EventArgs^ e) {
label1->Text = "Hello World";
}
};
#include <iostream>
using namespace std;
class BASE{
public:
BASE(int x, int y, int z);
~BASE();
void getInfo();
int a;
protected:
int b;
string Im;
private:
int c;
};
BASE::BASE(int x, int y, int z)
:a(x), b(y), c(z){
Im = "Base Class";
}
BASE::~BASE(){
cout << "BASE's destructor! " << Im << endl;
}
void BASE::getInfo(){
cout << "BASE::getInfo()" << " : " << Im << endl;
}
class DERIVED:public BASE{
public:
DERIVED(int x, int y, int z, int w);
~DERIVED();
void getInfo();
private:
int d;
};
DERIVED::DERIVED(int x, int y, int z, int w)
:BASE(x, y, z), d(w){
Im = "Derived Class";
}
DERIVED::~DERIVED(){
cout << "DERIVED's destructor! " << Im << endl;
}
void DERIVED::getInfo(){
cout << "DERIVED::getInfo()" << " : " << Im << endl;
}
int main()
{
BASE* base[2];
base[0] = new BASE(1, 2, 3);
base[1] = new DERIVED(4, 5, 6, 7);
base[0]->getInfo();
base[1]->getInfo();
cout << endl;
cout << "delete base[0]" << endl;
delete base[0];
cout << endl;
cout << "delete base[1]" << endl;
delete base[1];
return 0;
}
#include <iostream>
using namespace std;
class BASE{
public:
BASE(int x, int y, int z);
virtual ~BASE();
virtual void getInfo();
int a;
protected:
int b;
string Im;
private:
int c;
};
BASE::BASE(int x, int y, int z)
:a(x), b(y), c(z){
Im = "Base Class";
}
BASE::~BASE(){
cout << "BASE's destructor! " << Im << endl;
}
void BASE::getInfo(){
cout << "BASE::getInfo()" << " : " << Im << endl;
}
class DERIVED:public BASE{
public:
DERIVED(int x, int y, int z, int w);
virtual ~DERIVED();
virtual void getInfo();
private:
int d;
};
DERIVED::DERIVED(int x, int y, int z, int w)
:BASE(x, y, z), d(w){
Im = "Derived Class";
}
DERIVED::~DERIVED(){
cout << "DERIVED's destructor! " << Im << endl;
}
void DERIVED::getInfo(){
cout << "DERIVED::getInfo()" << " : " << Im << endl;
}
int main()
{
BASE* base[2];
base[0] = new BASE(1, 2, 3);
base[1] = new DERIVED(4, 5, 6, 7);
base[0]->getInfo();
base[1]->getInfo();
cout << endl;
cout << "delete base[0]" << endl;
delete base[0];
cout << endl;
cout << "delete base[1]" << endl;
delete base[1];
return 0;
}
#include <iostream>
using namespace std;
class BASE{
public:
BASE(int x, int y, int z);
~BASE();
void doit();
int a;
protected:
int b;
string Im;
private:
int c;
};
BASE::BASE(int x, int y, int z)
:a(x), b(y), c(z){
Im = "Base Class";
}
BASE::~BASE(){
cout << "BASE's destructor! " << Im << endl;
}
void BASE::doit(){
cout << "BASE::doit()" << endl;
cout << a << endl;
cout << b << endl;
cout << c << endl;
}
class DERIVED:public BASE{
public:
DERIVED(int x, int y, int z, int w);
~DERIVED();
void doit();
private:
int d;
};
DERIVED::DERIVED(int x, int y, int z, int w)
:BASE(x, y, z), d(w){
Im = "Derived Class";
}
DERIVED::~DERIVED(){
cout << "DERIVED's destructor! " << Im << endl;
}
void DERIVED::doit(){
cout << "DERIVED::doit()" << endl;
BASE::doit();
cout << d << endl;
}
int main()
{
BASE base(1, 2, 3);
base.doit();
DERIVED derived(4, 5, 6, 7);
derived.doit();
return 0;
}
#include <iostream>
using namespace std;
class BASE{
public:
void doit();
int a;
protected:
int b;
private:
int c;
};
class DERIVED:public BASE{
public:
void doit();
};
void BASE::doit(){
cout << "BASE::doit()" << endl;
cout << a << endl;
cout << b << endl;
cout << c << endl;
};
void DERIVED::doit(){
cout << "DERIVED::doit()" << endl;
BASE::doit();
cout << "---" << endl;
cout << a << endl;
cout << b << endl;
cout << c << endl; //ERROR: cannot access private of base class
}
int main()
{
BASE base;
base.doit();
DERIVED derived;
derived.doit();
return 0;
}
#include <iostream>
using namespace std;
string std_string;
int main()
{
cout << "STD String Test" << endl << endl;
std_string = "We wish you a merry Christmas and a Happy New Year!";
cout << "std_string = " << std_string << endl;
cout << "std_string.find(\"Christmas\") = " << std_string.find("Christmas") << endl;
cout << "std_string.substr(20, 9) = " << std_string.substr(20, 9) << endl;
cout << "std_string.insert(20, \"2011\") = " << std_string.insert(20, "2011 ") << endl;
cout << "std_string.erase(20, 5) = " << std_string.erase(20, 5) << endl;
cout << "std_string.replace(20, 6, \"X'\") = " << std_string.replace(20, 6, "X'") << endl;
return 0;
}
#include <iostream>
using namespace std;
class MyClass{
public:
MyClass(const int mSize);
MyClass(MyClass& src);
~MyClass();
void fill(char c);
void getInfo();
MyClass& operator=(const MyClass& src);
private:
int size;
char* ptToChar;
friend class MyFriend;
};
//Constructor with default size
MyClass::MyClass(const int mSize = 10)
{
size = mSize;
ptToChar = new char[size];
}
//Copy Constructor
MyClass::MyClass(MyClass& src){
size = src.size;
ptToChar = new char[size];
for(int i = 0; i < size; i++)
ptToChar[i] = src.ptToChar[i];
}
MyClass::~MyClass(){
cout << "MyClass Destructor: " << endl;
}
void MyClass::fill(char c){
for(int i = 0; i < size; i++)
ptToChar[i] = c;
}
void MyClass::getInfo()
{
cout << "size: " << size << endl;
for(int i = 0; i < size; i++)
cout << ptToChar[i];
cout << endl;
}
//Overload operator =
MyClass& MyClass::operator=(const MyClass& src){
if (this != &src){
delete[] ptToChar;
size = src.size;
ptToChar = new char[size];
for(int i = 0; i < size; i++)
ptToChar[i] = src.ptToChar[i];
}
return *this;
}
class MyFriend{
public:
void getFriendInfo(const MyClass& myfriend);
};
void MyFriend::getFriendInfo(const MyClass& myfriend){
cout << "size: " << myfriend.size << endl;
for(int i = 0; i < myfriend.size; i++)
cout << myfriend.ptToChar[i];
cout << endl;
}
int main()
{
MyClass myClass1(20);
myClass1.fill('A');
myClass1.getInfo();
MyClass myClass2(10);
myClass2 = myClass1;
myClass2.getInfo();
myClass1.fill('B');
myClass1.getInfo();
myClass2.getInfo();
cout << endl << "Create MyFriend friendA()" << endl;
MyFriend friendA;
friendA.getFriendInfo(myClass1);
friendA.getFriendInfo(myClass2);
return 0;
}
#include <iostream>
using namespace std;
class MyClass{
public:
MyClass(const int mSize);
MyClass(MyClass& src);
~MyClass();
void fill(char c);
void getInfo();
MyClass& operator=(const MyClass& src);
private:
int size;
char* ptToChar;
};
//Constructor with default size
MyClass::MyClass(const int mSize = 10)
{
size = mSize;
ptToChar = new char[size];
}
//Copy Constructor
MyClass::MyClass(MyClass& src){
size = src.size;
ptToChar = new char[size];
for(int i = 0; i < size; i++)
ptToChar[i] = src.ptToChar[i];
}
MyClass::~MyClass(){
cout << "MyClass Destructor: " << endl;
}
void MyClass::fill(char c){
for(int i = 0; i < size; i++)
ptToChar[i] = c;
}
void MyClass::getInfo()
{
cout << "size: " << size << endl;
for(int i = 0; i < size; i++)
cout << ptToChar[i];
cout << endl;
}
//Overload operator =
MyClass& MyClass::operator=(const MyClass& src){
if (this != &src){
delete[] ptToChar;
size = src.size;
ptToChar = new char[size];
for(int i = 0; i < size; i++)
ptToChar[i] = src.ptToChar[i];
}
return *this;
}
int main()
{
MyClass myClass1(20);
myClass1.fill('A');
myClass1.getInfo();
MyClass myClass2(10);
myClass2 = myClass1;
myClass2.getInfo();
myClass1.fill('B');
myClass1.getInfo();
myClass2.getInfo();
return 0;
}
#include <iostream>
using namespace std;
class MyClass{
public:
MyClass(const int mSize);
MyClass(MyClass& src);
~MyClass();
void fill(char c);
void getInfo();
private:
int size;
char* ptToChar;
};
//Constructor with default size
MyClass::MyClass(const int mSize = 10)
{
size = mSize;
ptToChar = new char[size];
}
//Copy Constructor
MyClass::MyClass(MyClass& src){
size = src.size;
ptToChar = new char[size];
for(int i = 0; i < size; i++)
ptToChar[i] = src.ptToChar[i];
}
MyClass::~MyClass(){
cout << "MyClass Destructor: " << endl;
}
void MyClass::fill(char c){
for(int i = 0; i < size; i++)
ptToChar[i] = c;
}
void MyClass::getInfo()
{
cout << "size: " << size << endl;
for(int i = 0; i < size; i++)
cout << ptToChar[i];
cout << endl;
}
int main()
{
MyClass myClass1(20);
myClass1.fill('A');
myClass1.getInfo();
MyClass myClass2(myClass1); //Using our Copy Constructor
myClass2.getInfo();
myClass1.fill('B');
myClass1.getInfo();
myClass2.getInfo();
return 0;
}
#include <iostream>
using namespace std;
class MyClass{
public:
MyClass(const int mSize);
~MyClass();
void fill(char c);
void getInfo();
private:
int size;
char* ptToChar;
};
//Constructor with default size
MyClass::MyClass(const int mSize = 10)
{
size = mSize;
ptToChar = new char[size];
}
MyClass::~MyClass(){
cout << "MyClass Destructor: " << endl;
}
void MyClass::fill(char c){
for(int i = 0; i < size; i++)
ptToChar[i] = c;
}
void MyClass::getInfo()
{
cout << "size: " << size << endl;
for(int i = 0; i < size; i++)
cout << ptToChar[i];
cout << endl;
}
int main()
{
MyClass myClass1;
myClass1.fill('A');
myClass1.getInfo();
MyClass myClass2(myClass1); //Using default Copy Constructor
myClass2.getInfo();
/*
* Both myClass1.ptToChar and myClass2.ptToChar point to
* the same char[size], such that fill in myClass1 affect
* the array also!!!
*/
myClass1.fill('B');
myClass2.getInfo();
return 0;
}
#include <iostream>
using namespace std;
class MyClass{
public:
MyClass();
~MyClass();
private:
string myName;
string myNote;
};
//Constructor with initializer list
MyClass::MyClass()
:myName("initName"), myNote("initNote")
{
cout << "MyClass Constructor: " << myName << endl;
}
MyClass::~MyClass(){
cout << "MyClass Destructor: " << myName << endl;
}
int main()
{
MyClass myClass1;
return 0;
}
#include <iostream>
using namespace std;
class MyClass{
public:
MyClass();
MyClass(string note, const string mName = "DEFAULT_NAME");
~MyClass();
private:
string myName;
string myNote;
};
MyClass::MyClass(){
myName = "default constructor without argument";
myNote = "";
cout << "MyClass Constructor: " << myName << endl;
}
MyClass::MyClass(string note, const string mName){
myName = mName;
myNote = note;
cout << "MyClass Constructor: " << myName << " : " << myNote << endl;
}
MyClass::~MyClass(){
cout << "MyClass Destructor: " << myName << endl;
}
int main()
{
MyClass myClass1;
MyClass myClass2("Using default Name");
MyClass myClass3("with name", "MyClass 3");
MyClass copyClass(myClass3);
return 0;
}
#include <iostream>
using namespace std;
class MyClass{
public:
MyClass();
MyClass(string note, const string mName = "DEFAULT_NAME");
MyClass(MyClass& src); //Copy Constructor
~MyClass();
private:
string myName;
string myNote;
};
MyClass::MyClass(){
myName = "default constructor without argument";
myNote = "";
cout << "MyClass Constructor: " << myName << endl;
}
//Copy Constructor
MyClass::MyClass(MyClass& src){
myName = src.myName;
myNote = src.myNote;
cout << "Copy Constructor: " << myName << " : " << myNote << endl;
}
MyClass::MyClass(string note, const string mName){
myName = mName;
myNote = note;
cout << "MyClass Constructor: " << myName << " : " << myNote << endl;
}
MyClass::~MyClass(){
cout << "MyClass Destructor: " << myName << endl;
}
int main()
{
MyClass myClass1;
MyClass myClass2("Using default Name");
MyClass myClass3("with name", "MyClass 3");
MyClass copyClass(myClass3);
return 0;
}
#include <iostream>
using namespace std;
class MyClass{
public:
MyClass();
MyClass(string note, const string mName = "DEFAULT_NAME");
~MyClass();
private:
string myName;
string myNote;
};
MyClass::MyClass(){
myName = "default constructor without argument";
myNote = "";
cout << "MyClass Constructor: " << myName << endl;
}
MyClass::MyClass(string note, const string mName){
myName = mName;
myNote = note;
cout << "MyClass Constructor: " << myName << " : " << myNote << endl;
}
MyClass::~MyClass(){
cout << "MyClass Destructor: " << myName << endl;
}
int main()
{
MyClass myClass1;
MyClass myClass2("Using default Name");
MyClass myClass3("with name", "MyClass 3");
return 0;
}
#include <iostream>
using namespace std;
class MyClass{
public:
MyClass(string mName);
~MyClass();
private:
string myName;
};
MyClass::MyClass(string mName){
myName = mName;
cout << "MyClass Constructor: " << myName << endl;
}
MyClass::~MyClass(){
cout << "MyClass Destructor: " << myName << endl;
}
int main()
{
cout << "Hello world!" << endl;
MyClass myClass("MyClass 1");
MyClass* myClassPtr = new MyClass("MyClass 2: created using new");
delete myClassPtr;
return 0;
}
#include <iostream>
using namespace std;
void function(int ArrayPassed[], unsigned len);
int main()
{
int array[] = {1, 2, 3, 4, 5};
unsigned length = 5;
cout << endl << "before fnction()" << endl;
for(unsigned i = 0; i < length; i++){
cout << array[i] << " ";
}
function(array, length);
cout << endl << "after fnction()" << endl;
for(unsigned i = 0; i < length; i++){
cout << array[i] << " ";
}
cout << endl;
return 0;
}
void function(int ArrayPassed[], unsigned len){
for(unsigned i = 0; i < len; i++){
ArrayPassed[i] *= ArrayPassed[i];
}
}
#include <iostream>
using namespace std;
void function(int byValue, int& byRef);
int main()
{
int a = 5;
int b = 10;
cout << endl << "before fnction()" << endl;
cout << "a (byValue) = " << a << endl;
cout << "b (byRef) = " << b << endl;
function(a, b);
cout << endl << "after fnction()" << endl;
cout << "a (byValue) = " << a << endl;
cout << "b (byRef) = " << b << endl;
return 0;
}
void function(int byValue, int& byRef){
byValue++;
byRef++;
}
#include <iostream>
using namespace std;
int main()
{
cout << endl << "the loop break when i = 5" << endl;
for(int i = 1; i < 10; i ++){
if (i == 5) break;
cout << i << endl;
}
cout << endl << "the loop skip 5 with continue" << endl;
for(int i = 1; i < 10; i ++){
if (i == 5) continue;
cout << i << endl;
}
return 0;
}
#include <iostream>
using namespace std;
int main()
{
cout << (true ? "It's True" : "It's False") << endl;
cout << (false ? "It's True" : "It's False") << endl;
return 0;
}
#include <iostream>
using namespace std;
int main()
{
string name = "Eric L";
string& refName = name;
cout << refName << endl;
refName = "Changed!";
cout << refName << endl;
cout << name << endl;
return 0;
}
#include <iostream>
using namespace std;
int main()
{
string a = "Hello";
string b = "World!";
string c = a + b;
cout << c << endl;
cout << "c.size() = " << c.size() << endl;
for(unsigned i = 0; i < c.size(); i++){
cout << "c[" << i << "] : " << (char)c[i] << endl;
}
return 0;
}
#include <iostream>
using namespace std;
int main()
{
char array[] = {'A', 'B', 'C', 'D', 'E'};
char* PointerToArray = array;
char* PointerToChar = &array[0];
cout << "array = " << array << endl;
cout << "PointerToArray = " << PointerToArray << endl;
cout << "PointerToChar = " << PointerToChar << endl;
cout << endl;
cout << "array[2] = " << array[2] << endl;
cout << "PointerToArray[2] = " << PointerToArray[2] << endl;
cout << endl;
cout << "array + 2 = " << array + 2 << endl;
cout << "PointerToArray + 2 = " << PointerToArray + 2 << endl;
cout << "PointerToChar + 2 = " << PointerToChar + 2 << endl;
return 0;
}
#include <iostream>
using namespace std;
int main()
{
cout << "sizeOf(bool) = " << sizeof(bool) <<endl;
cout << "sizeOf(short) = " << sizeof(short) <<endl;
cout << "sizeOf(int) = " << sizeof(int) <<endl;
cout << "sizeOf(long) = " << sizeof(long) <<endl;
cout << "sizeOf(float) = " << sizeof(float) <<endl;
cout << "sizeOf(double) = " << sizeof(double) <<endl;
cout << "sizeOf(char) = " << sizeof(char) <<endl;
cout << "sizeOf(void) = " << sizeof(void) <<endl;
cout << "sizeOf(NULL) = " << sizeof(NULL) <<endl;
cout << "sizeOf(void *) = " << sizeof(void *) << " - (pointer)" << endl;
return 0;
}
#include <iostream>
using namespace std;
int main()
{
for (char i = 'A'; i <= 'Z'; i++){
cout << i << " : " << int(i) << endl;
}
for (char i = 'a'; i <= 'z'; i++){
cout << i << " : " << int(i) << endl;
}
return 0;
}
#include <iostream>
#include <cstdlib>
using namespace std;
void bubblesort();
void swap(int *p1, int *p2);
int data[10];
int main () {
//Prepare data
for (int i = 0; i < 10; i++) {
data[i] = rand() % 100;
}
cout << "data before bubble sort:" << endl;
for (int i = 0; i < 10; i++)
cout << data[i] << " ";
bubblesort();
cout << "data after bubble sort:" << endl;
for (int i = 0; i < 10; i++)
cout << data[i] << " ";
return 0;
}
void bubblesort() {
int i, j, min;
int size = sizeof(data)/sizeof(int);
cout << endl << "size = " << size << endl;
for(i = 0; i < size - 1; i++) {
min = i;
for (j = i + 1; j < size; j++){
if (data[j] < data[min])
min = j;
}
if (i != min){
int tmp = data[i];
data[i] = data[min];
data[min] = tmp;
}
}
}
