add Link/Link4

Link/Link4/CMakeLists.txt

@@ -0,0 +1,6 @@
+cmake_minimum_required(VERSION 3.10)
+project(CheckLinkage)
+
+set(CMAKE_CXX_STANDARD 17)
+
+add_executable(main main.cpp)

Link/Link4/main.cpp

@@ -0,0 +1,65 @@
+static int internalVar = 42;
+int Var = 34; 
+
+void internalFunc() {
+    static int localStatic = 0;
+}
+
+class MyClass{  // 本质上此时MyClass只是声明 
+    public:
+        int ClassVar = 23; 
+        static int ClassStatic;  // 在此只是声明
+        void printVar();
+};
+int MyClass::ClassStatic = 10;  //外部链接 
+void MyClass::printVar(){
+    static int b = 33; 
+    int a = 23;
+}
+
+template<typename T> T th(T a, T b){
+    return a + b; 
+} 
+
+static MyClass mc; 
+MyClass mac; 
+
+
+template<class T2,class T3>  // 模板函数 --(1)
+int h(T2 a,T3 b){  // 返回值中有模板形参
+    return a+b;
+}
+
+int h(int a, int b){  // 普通函数  --(2) 
+    return a+b;
+}
+
+template<> int h(float a, float b){  // 对函数特化 --(3) 
+    return a+b;
+} 
+
+template<typename T> 
+class TypeClass{
+    public: 
+        T kk;
+        int ik = 789; 
+        static T staticKK; 
+};
+
+template class TypeClass<int>;  // 实例化声明，会实例化模板 
+
+TypeClass<int> tc;  
+
+template<typename T>
+static T TypeClass<T>::staticKK;  // 泛型定义
+
+template<> int TypeClass<int>::staticKK = 10;
+
+int main() {
+    // internalFunc();
+    MyClass mcc;  
+    th<int>(2,3); 
+    th<double>(2.0,3.0);
+    h(2.3f,3.6f);
+    return 0;
+}

Link/Link4/main1.cpp

@@ -0,0 +1,6 @@
+static int internalVar = 42;
+int Var = 34; 
+
+int main(){
+    return 0; 
+}

Link/Link4/main2.cpp

@@ -0,0 +1,22 @@
+// 普通函数
+void interFunc(){
+    static int localStatic = 22; 
+}
+
+// 模板函数
+template<class T2, class T3>  // 模板函数 --(1)
+int h(T2 a,T3 b){  // 返回值中有模板形参
+    return a+b;
+}
+
+int h(int a, int b){  // 普通函数  --(2) 
+    return a+b;
+}
+
+template<> int h(float a, float b){  // 对模板函数特化 --(3) 
+    return a+b;
+} 
+
+int main(){
+    return 0; 
+}

Link/Link4/main3.cpp

@@ -0,0 +1,24 @@
+// 普通函数
+void interFunc(){
+    static int localStatic = 22; 
+}
+
+// 模板函数
+template<class T2, class T3>  // 模板函数 --(1)
+int h(T2 a,T3 b){  // 返回值中有模板形参
+    return a+b;
+}
+
+int h(int a, int b){  // 普通函数  --(2) 
+    return a+b;
+}
+
+template<> int h(float a, float b){  // 对模板函数特化 --(3) 
+    return a+b;
+} 
+
+template int h(char, char); // 实例化声明
+
+int main(){
+    return 0; 
+}

Link/Link4/main4.cpp

@@ -0,0 +1,23 @@
+class MyClass{  // 本质上此时MyClass只是声明 
+    public:
+        int ClassVar = 23;  //定义，但是依赖于class对象(无链接)
+        static int ClassStatic;  // 在此只是声明（不会定义）
+        void printVar(); // 声明不定义
+        void inlineFunc(){ // 非静态函数 类内定义
+            static int kk = 33; 
+        }
+        static void staticFunc1(){} // 静态函数  类内定义 
+        static void staticFunc2();
+};
+int MyClass::ClassStatic = 10;  // 静态变量  类外定义 　　
+void MyClass::printVar(){  // 非静态函数 类外定义 
+    static int b = 33; 
+    int a = 23;
+}
+void MyClass::staticFunc2(){}  // 静态函数 类外定义
+
+MyClass mc; 
+
+int main(){
+    return 0; 
+}

Link/Link4/main5.cpp

@@ -0,0 +1,32 @@
+template<typename T> 
+class TypeClass{
+    public: 
+        T kk;
+        int ik = 789; 
+        static T staticKK; 
+        void Func1();
+        void Func4(){};
+        void Func2(T a);
+        void Func3(T a){};
+        static void staticFunc1();
+        static void staticFunc4(){};
+        static void staticFunc2(T a);
+        static void staticFunc3(T a){};
+};
+template<typename T>
+void TypeClass<T>::Func1(){}
+
+template<typename T>
+void TypeClass<T>::Func2(T a){}
+
+template<typename T>
+void TypeClass<T>::staticFunc1(){}
+
+template<typename T>
+void TypeClass<T>::staticFunc2(T a){}
+
+template class TypeClass<int>;  // 实例化声明，会实例化模板类
+
+int main(){
+    return 0; 
+}

Link/readme.md

@@ -10,7 +10,7 @@ ref: https://www.cnblogs.com/shaochuanhe/articles/14238153.html
 
 # `class`
 `class`中成员变量/函数的内部链接性和外部链接性。见`./Link3`
-1. 类的定义是内部链接 ??? (模板类实例化具有外部链接特性，而非模板类不具有链接性？)
+1. 类定义（Class Definition） 本身只是一个类型声明，并不在编译过程中生成可供链接的符号，不具备链接性(内部链接/外部链接)
 2. 静态成员变量的定义必须在类外，且其为**外部链接**. `Link3/a.h`中 `MyClass::a` 必须定义在类外，并且如果放在a.h中，则链接时报错： multiple definition of `MyClass::a'
 3. 静态成员函数, 其定义在类外时，是外部链接，其行为动作同`2.`; 定义在类内时，是内联函数，为内部链接. 见`MyClass::printA`
 4. 非静态成员变量, 其为类的每个实例所特有的，它们在创建对象时被分配内存，其没有链接性一说

template/readme.md

@@ -1,9 +1,15 @@
 ref: [C++template教程](https://qixinbo.info/2017/07/09/cplusplus-template/) 
 
-- 类模板中的友元
-    1. 非模板函数/类的友元 `main51.cpp`  
-        普通函数/类作为类模板的友元,没啥可讲的
-    2. 约束性模板函数/类的友元 `main52.cpp`  
-        模板函数/类作为类模板的友元,只有type相同的类模板和友元之间才能成为朋友,可以理解为在类模板中使用type对友元函数进行实例化
-    3. 非约束性模板函数/类的友元 `main.cpp`  
-        模板函数/类作为类模板的友元, 即便时不同的type的类模板和友元之间也能成为朋友
+# 类模板中的友元
+1. 非模板函数/类的友元 `main51.cpp`  
+    普通函数/类作为类模板的友元,没啥可讲的
+2. 约束性模板函数/类的友元 `main52.cpp`  
+    模板函数/类作为类模板的友元,只有type相同的类模板和友元之间才能成为朋友,可以理解为在类模板中使用type对友元函数进行实例化
+3. 非约束性模板函数/类的友元 `main.cpp`  
+    模板函数/类作为类模板的友元, 即便时不同的type的类模板和友元之间也能成为朋友
+
+# 模板函数/类
+1. 模板函数/类的定义和声明通常要放在一起。
+2. 可以前向声明模板函数/类的存在：`template <typename T> class MyTemplateClass;`, 但是如果只是声明，是无法实例化这个模板的
+3. 模板函数/类可以提前实例化，从而避免在使用时才进行实例化。`template int h<int>(int a, int b);` 
+4. 每个翻译单元中使用模板时，都会对模板函数/类实例化，在链接时会处理这些重复的实例化，从而保证此项目中每个类型只有一个实例化