bank.cpp

   

    
#include <iostream>
    
using namespace std;
    
//namespace {
    
	void print (int money) {
    
		cout << money << endl;
    
	}
    
//}
    
// 農行名字空間
    
namespace abc {
    
	int balance = 0;
    
	void save (int money) {
    
		balance += money;
    
	}
    
	void draw (int money) {
 

    
		balance -= money;
    
	}
    
}
    
namespace abc {
    
	void salary (int money) {
    
		balance += money;
    
	}
    
	void print (int money) {
    
		cout << "農行：";
    
		::print (money);
    
	}
    
}
    
// 建行名字空間
    
namespace ccb {
    
	int balance = 0;
    
	void save (int money) {
    
		balance 
 
+= money;
    
	}
    
	void draw (int money) {
    
		balance -= money;
    
	}
    
	void salary (int money) {
    
		balance += money;
    
	}
    
}
    
int main (void) {
    
	using namespace abc; // 名字空間指令
    
	save (5000);
    
	cout << "農行：" << balance << endl;
    
	draw (3000);
    
	cout <<
 
 "農行：" << balance	<< endl;
    
	ccb::save (8000);
    
	cout << "建行：" << ccb::balance << endl;
    
	ccb::draw (5000);
    
	cout << "建行：" << ccb::balance << endl;
    
	using ccb::salary; // 名字空間宣告
    
//	using abc::salary;
    
	salary (6000);
    
	cout << "建行：" << ccb::balance << endl;
    
	abc::print (abc::balance);
    
	return 0;
    
}
   

 先進行編譯，然後再取別名執行檔案； g++ bank.cpp g++ -o bank bank.cpp ./bank

 std:: 名字空間： 作用域限定運算子，相當於：“的”字元。

---

bool.cpp

   

    
#include <iostream>
    
using namespace std;
    
void print (bool sex) {
    
	if (sex) 
    
		cout << "男生" << endl;
    
	else
    
		cout << "女生" << endl;
    
}
    
int main (void) {
    
	bool b = true;
    
	cout << sizeof (b) << endl;
    
	cout << b << endl;
    
	b = false;
    
	cout << b << endl;
    
	b = 3.14;
    
	cout << b << endl;
    
	char* p = NULL;
    
	b = p;
    
	cout << b << endl;
    
	cout << boolalpha << b << endl;
    
	bool sex;
    
	sex = 3;
    
	print (sex);
    
	return 0;
    
}
   

  ----------------------------------------------------- 因為，char *p = null, b = p; 此時，boolalpha = false; boolalpha以字元顯示方式進行格式控制；
 
因為b是bool型別的，b = 3.14 ， cout << b << endl; 後的值為1. --------------------------------------------------  sex  = 3  是bool型別的，猜測sex是True,男生”； -------------------------------- 驗證：    ---------------------------- sizeof(空結構)-> 1

---

cfunc.c

   

    
void foo (int a) {}
   

defarg.cpp

   

    
#include <iostream>
    
using namespace std;
    
void foo (int a = 10, double b = 0.01, 
    
	const char* c = "tarena");
    
void foo (void) {}
    
void bar (int) {
    
	cout << "bar(int)" << endl;
    
}
    
void bar (int, double) {
    
	cout << "bar(int,double)" << endl;
    
}
    
int main (void) {
    
	foo (1, 3.14, "hello");
    
	foo (1, 3.14);
    
	foo (1);
    
//	foo (); // 歧義
    
	bar (100);
    
	bar (100, 12.34);
    
	return 0;
    
}
    
void foo (int a /* = 10 */, double b /* = 0.01 */,
    
	const char* c /* = "tarena" */) {
    
	cout << a << ' ' << b << ' ' << c << endl;
    
}
   

 -----------------------    過載：在同一作用域中，函式名相同，引數表不同的函式，構成過載關係
 int foo (int a,  double b) {}   int foo (int b, double a)   函式名相同，引數名相同的不構成過載關係；   關注的是引數表的型別，不關心其名字；
過載解析： （1）最優匹配原則； （2）最小工作量原則；
函式名標識的是函式的地址，C++中函式名 可以重複，但是地址不一樣。 const char * c= "tarena" 表示預設值；預設值一律靠右； 預設引數放在宣告語句當中 ，宣告是給編譯器看的；

過載：需要用同一個函式（函式名是死的）來實現兩個不同的功能；  v1 : void decode (int arg) {...}  v2:  void decode (void)  {} ---------------------------------------------
  兩個不同 函式用同一個名；  只有型別而沒有名字的形參，渭之“啞元”。  佔著位置而不起任何作用； -------------------------------------------------- gcc -std=c++  0x 使用2011標準去編譯；
g++ 1.cpp -std=c++ 0x -------------------------------------------- （1）如果呼叫一個函式時，沒有提供實參，那麼對應的形參就取預設值； （2）如果一個引數帶有預設值，那麼它後面的所有引數都必須都帶有預設值； （3）如果一個函式宣告和定義分開，那麼預設引數只能放在宣告中； （4）避免和過載發生歧義； （5）只有型別而沒有名字的形參，謂之啞元；

---

enum.cpp

   

    
#include <iostream>
    
using namespace std;
    
int main (void) {
    
	enum E {a, b, c};
    
	E e;
    
	e = a;
    
	e = b;
    
	e = c;
    
//	e = 1000;
    
//	e = 1;
    
	return 0;
    
}
   

 在這種 情況下，程式可以順利進行編譯；
   在這種情況下，編譯出錯。  列舉是 一種獨立的資料型別，和整型之間不能進行隱式轉換。

---

hello.cpp

   

    
#include <iostream>
    
int main (void) {
    
	std::cout << "Hello, World !" << std::endl;
    
	int i;
    
	double d;
    
	char s[256];
    
//	scanf ("%d%lf%s", &i, &d, s);
    
	std::cin >> i >> d >> s;
    
//	printf ("%d %lf %s\n", i, d, s);
    
	std::cout << i << ' ' << d << ' ' << s << '\n';
    
	return 0;
    
}
   

 
 輸出： cout - 標準輸出物件；(控制檯輸出物件)  輸入： cin   - 標準輸入物件； 插入運算子： << （把字串的字面值插入到cout內） 提取運算子： >>
std::cout (控制檯輸出物件) << "Hello,world !" <<(多次插入) std::endl;(換行\n)

---

math.cpp

   

    
extern "C" {
    
int add (int a, int b) {
    
	return a + b;
    
}
    
int sub (int a, int b) {
    
	return a - b;
    
}
    
}
    
/*
    
extern "C" int add (int a, int b, int c) {
    
	return a + b + c;
    
}
    
*/
   

calc.c3

   

    
#include <stdio.h>
    
int add (int, int);
    
int main (void) {
    
	printf ("%d\n", add (10, 20));
    
	return 0;
    
}
   

---

nsover.cpp

   

    
#include <iostream>
    
using namespace std;
    
namespace ns1 {
    
	int foo (int a) {
    
		cout << "ns1::foo(int)" << endl;
    
		return a;
    
	}
    
};
    
namespace ns2 {
    
	double foo (double a) {
    
		cout << "ns2::foo(double)" << endl;
    
		return a;
    
	}
    
};
    
int main (void) {
    
	using namespace ns1;
    
	using namespace ns2;
    
	cout << foo (10) << endl;
    
	cout << foo (1.23) << endl;
    
	using ns1::foo;
    
	cout << foo (10) << endl;
    
	cout << foo (1.23) << endl;
    
	using ns2::foo;
    
	cout << foo (10) << endl;
    
	cout << foo (1.23) << endl;
    
	return 0;
    
}
   

using ns1::foo; ns1中的foo被引入到作用域中了；
 

---

overload.cpp

   

    
#include <iostream>
    
using namespace std;
    
void foo (int a) {
    
	cout << "foo(int)" << endl;
    
}
    
void bar (int a) {}
    
//int foo (int a) {}
    
int foo (int a, double b) {
    
	cout << "foo(int,double)" << endl;
    
}
    
int foo (double a, int b) {
    
	cout << "foo(double,int)" << endl;
    
}
    
//int foo (int b, double a) {}
    
int main (void) {
    
	foo (100);
    
	foo (100, 1.23);
    
	foo (1.23, 100);
    
//	foo (100, 100);
    
	return 0;
    
}
   

 

---

struct.c

   

    
#include <stdio.h>
    
int main (void) {
    
	struct A {};
    
	printf ("%d\n", sizeof (struct A));
    
	struct A a;
    
	struct A* pa = &a;
    
	printf ("%p\n", pa);
    
	return 0;
    
}
   

C語言中的空結構大小為0；

---

struct.cpp

   

    
#include <iostream>
    
using namespace std;
    
struct Student {
    
	char name[128];
    
	int age;
    
	void who (void) {
    
		cout << "我叫" << name << "，今年" << age
    
			<< "歲了。" << endl;
    
	}
    
};
    
int main (void) {
    
	Student student = {"張飛", 25}, *ps = &student;
    
	student.who ();
    
	ps->who ();
    
	struct A {};
    
	cout << sizeof (A) << endl;
    
	return 0;
    
}
   

  C++中類和結構沒有區別；    sizeof （空結構） ->  1；

---

union.cpp

   

    
#include <iostream>
    
using namespace std;
    
int main (void) {
    
	// 匿名聯合
    
	union {
    
		int x;
    
		char c[4] /*= {'A', 'B', 'C', 'D'}*/;
    
	};
    
	cout << (void*)&x << ' ' << (void*)c << endl;
    
	x = 0x12345678;
    
	for (int i = 0; i < 4; ++i)
    
		cout << hex << (int)c[i] << ' ';
    
	cout << endl;
    
	return 0;
    
}
   

     gcc -std=c++0x 使用2011編譯器去編譯；-2011標準；









來自為知筆記(Wiz)