fatal error LNK1169: 找到一个或多个多重定义的符号；这个问题出现的情况。主要是重定义（多次定义）了某些变量名/函数名。

今天遇到的这个我认为是写代码的规范不好而导致的Error！自己折腾了一会儿才解决，故用这篇博客记录一下！

源码：

rational.h

#ifndef __RATIONAL_H__
#define __RATIONAL_H__
#include<iostream>
#include<memory>
using namespace std;
class Rational {
public:
    inline Rational(int numerator = 0, int denominator = 1)
        :m_Numerator(new int(numerator)), m_Denominator(new int(denominator)) {}
    Rational(const Rational& rhs);
    const Rational& operator=(const Rational& rhs);
    // const Rational& operator*(const Rational& rhs);
    inline int numerator()const { return *m_Numerator; }
    inline int denominator()const { return *m_Denominator; }
    void reviseNumerator(int val);
    void reviseDenominator(int val);
    inline ~Rational() {
        this->m_Numerator = nullptr;//置为nullpr！
        this->m_Denominator = nullptr;//置为nullpr！
    }
private:
    std::shared_ptr<int> m_Numerator;
    std::shared_ptr<int> m_Denominator;
};
//non-member operator* function !
const Rational operator*(const Rational& rhs1, const Rational& rhs2) {
    int t_numerator = rhs1.numerator() * rhs2.numerator();
    int t_denominator = rhs1.denominator() * rhs2.denominator();
    return Rational(t_numerator, t_denominator);
}
#endif //__RATIONAL_H__

rational.cpp

#include"rational.h"

void Rational::reviseNumerator(int val) {
    m_Numerator.reset();//让强引用计数-到0，也即释放原来的空间了！
    this->m_Numerator = std::make_shared<int>(val);
}
void Rational::reviseDenominator(int val) {
    m_Denominator.reset();//让强引用计数-到0，也即释放原来的空间了！
    this->m_Denominator = std::make_shared<int>(val);
}

// const Rational& Rational::operator*(const Rational& rhs){
//     this->reviseNumerator(*(m_Numerator) * rhs.numerator());
//     this->reviseDenominator(*(m_Denominator) * rhs.denominator());
//     return *this;
// }
Rational::Rational(const Rational& rhs) {
    m_Numerator.reset();//让强引用计数-到0，也即释放原来的空间了！
    this->m_Numerator = std::make_shared<int>(rhs.numerator());

    m_Denominator.reset();//让强引用计数-到0，也即释放原来的空间了！
    this->m_Denominator = std::make_shared<int>(rhs.denominator());
}

const Rational& Rational::operator=(const Rational& rhs) {
    m_Numerator.reset();//让强引用计数-到0，也即释放原来的空间了！
    this->m_Numerator = std::make_shared<int>(rhs.numerator());

    m_Denominator.reset();//让强引用计数-到0，也即释放原来的空间了！
    this->m_Denominator = std::make_shared<int>(rhs.denominator());
    return *this;
}

在windows下写Cpp代码遇到以下错误时：

1>------ 已启动生成: 项目: Project3, 配置: Debug x64 ------
1>rational.cpp
1>LINK : 没有找到 E:\C++learning\C++并发与多线程编程\Project3\x64\Debug\Project3.exe 或上一个增量链接没有生成它；正在执行完全链接
1>rational.obj : error LNK2005: "class Rational const __cdecl operator*(class Rational const &,class Rational const &)" (??D@YA?BVRational@@AEBV0@0@Z) 已经在 6.10.obj 中定义
1>E:\C++learning\C++并发与多线程编程\Project3\x64\Debug\Project3.exe : fatal error LNK1169: 找到一个或多个多重定义的符号
1>已完成生成项目“Project3.vcxproj”的操作 - 失败。
========== 生成: 成功 0 个，失败 1 个，最新 0 个，跳过 0 个 ==========

或者在linxu下写Cpp代码遇到以下错误时：

        这其实都是同一个问题！即：

        你在.h头文件中定义了非成员函数（non-member function）！这样别的.cpp文件多次对该.h头文件进行inlcude时就会将同一份函数多次include进不同的.cpp源文件来，这就导致了fatal error LNK1169: 找到一个或多个多重定义的符号的错误提示！这能Link链接才怪呢！！！

下面是把一份非成员变量的定义写在了上述的rational.h头文件中，同样会报相同fatal error LNK1169: 找到一个或多个多重定义的符号的错误！（此时是把同一份非成员变量include到多个不同的.cpp源文件中去了）

        解决方法：把all的（non-member function）放在对应该.h的.cpp文件中即可deal！（是不是觉得很简单？）

        是的，在日常coding Cpp代码时，可能会有非常多令人意外的Error！这都是因为平时写代码不太规范导致的！既浪费时间又浪费脑力！还吃力不讨好的！所有日后我们coding时，必须规范自己的代码！千万不能写一出想一出！

        正确做法是：将non-member operator* function 另外放置于一个头文件并将其实现代码放在一个与头文件对应的.cpp源文件当中去！

RationalOperatorMultply.h：

#ifndef __RATIONALOPERATORMULTIPLY_H__
#define __RATIONALOPERATORMULTIPLY_H__
#include"rational.h"
const Rational operator*(const Rational& rhs1,const Rational& rhs2);

#endif //__RATIONALOPERATORMULTIPLY_H__

RationalOperatorMultply.cpp：

#include"RationalOperatorMultply.h"
//non-member operator* function !
const Rational operator*(const Rational& rhs1,const Rational& rhs2){
    auto t_numerator = rhs1.numerator() * rhs2.numerator();
    auto t_denominator = rhs1.denominator() * rhs2.denominator();
    return Rational(t_numerator,t_denominator);
    // or
    // return Rational(rhs1.numerator() * rhs2.numerator(),
    //             rhs1.denominator() * rhs2.denominator());
}

rational.h：

#ifndef __RATIONAL_H__
#define __RATIONAL_H__
#include<iostream>
#include<memory>
using namespace std;
class Rational{
public:
    inline Rational(int numerator = 0,int denominator = 1)
        :m_Numerator(new int(numerator)),m_Denominator(new int(denominator)){}
    Rational(const Rational& rhs);
    const Rational& operator=(const Rational& rhs);
    // const Rational& operator*(const Rational& rhs);
    inline int numerator()const { return *m_Numerator;}
    inline int denominator()const{ return *m_Denominator;}
    void reviseNumerator(int val); 
    void reviseDenominator(int val);
    inline ~Rational(){
        this->m_Numerator = nullptr;//置为nullpr！
        this->m_Denominator = nullptr;//置为nullpr！
    }
private:
    std::shared_ptr<int> m_Numerator;
    std::shared_ptr<int> m_Denominator;
};

#endif //__RATIONAL_H__

rational.cpp：

#include"rational.h"

void Rational::reviseNumerator(int val){
    m_Numerator.reset();//让强引用计数-到0，也即释放原来的空间了！
    this->m_Numerator = std::make_shared<int>(val);
}
void Rational::reviseDenominator(int val){
    m_Denominator.reset();//让强引用计数-到0，也即释放原来的空间了！
    this->m_Denominator = std::make_shared<int>(val);
}

// const Rational& Rational::operator*(const Rational& rhs){
//     this->reviseNumerator(*(m_Numerator) * rhs.numerator());
//     this->reviseDenominator(*(m_Denominator) * rhs.denominator());
//     return *this;
// }
Rational::Rational(const Rational& rhs){
    m_Numerator.reset();//让强引用计数-到0，也即释放原来的空间了！
    this->m_Numerator = std::make_shared<int>(rhs.numerator());

    m_Denominator.reset();//让强引用计数-到0，也即释放原来的空间了！
    this->m_Denominator = std::make_shared<int>(rhs.denominator());
}

const Rational& Rational::operator=(const Rational& rhs){
    m_Numerator.reset();//让强引用计数-到0，也即释放原来的空间了！
    this->m_Numerator = std::make_shared<int>(rhs.numerator());

    m_Denominator.reset();//让强引用计数-到0，也即释放原来的空间了！
    this->m_Denominator = std::make_shared<int>(rhs.denominator());
    return *this;
}

main.cpp：

#include<iostream>
#include"person.h"
#include"student.h"
#include"rational.h"
#include"RationalOperatorMultply.h"
using namespace std;
int main(void){
    Rational oneEighth(1,8);
    Rational oneHalf(1,2);
    Rational res = oneEighth * oneHalf;
    res = oneHalf * 2;//oneHalf * int(2)==>oneHalf.operator*(2) *const Rational rhs(2);//√!
    res = 2 * oneHalf;//int(2) * oneHalf ==> const Rational rhs(2) * oneHalf;//√!
    cout<<"res's numerator = "<< res.numerator()<<" res's denominator = "<< res.denominator()<<endl;
    return 0;
}

目前，我个人认为的Cpp规范的代码的书写格式为：

①：非成员函数/非成员变量一般都放在独立的.h头文件中并在对应的.cpp源文件中放其实现代码。

②：头文件防止重复包含的代码应该这么写：（不要偷懒只写一句#pragma once，因为不同的编译器有可能不兼容，要用各平台和编译器都兼容的方式来写）

#ifndef __XXX_H__
#define __XXX_H__
// codes
#endif //__XXX_H__

③：类模板和函数模板也要放在.h头文件中，当然，因为是模板，因此类模板声明和实现放在同一个.h下ok的，函数模板的声明和实现放在同一个.h中也ok！

④：对于函数体（{body;}）比较少的函数，可以考虑用inline声明一下，虽然编译器不同，可能无法真正做到inline，但写了万一能做到inline呢？对吧，如果做到了还能提高你代码的效率呢！

后续coding学习时会继续补充！未完待续~

我好像一直以来都以为编译链接的时候，在头文件里用了条件编译#ifndef #define #endif或pragma once就不会出现multiple definition of xx的问题，直到昨天…
情形如下，我在头文件里定义了一个函数而不是声明，然后两个cpp文件都include了这个头文件，最后链接的时候就出现了以上问题。因为对编译的理解不够才导致了这个问题。
头文件如下：

#ifndef HEADER_H
#define HEADER_H

#include <iostream>
#include <string>
using namespace std;
void print(string &message) { cout << message << endl; }

#endif

cpp1如下：

#include "header.h"

void fun() { print("hello world"); }

main.cpp如下：

#include "header.h"

extern void fun();
int main() { 
 fun();
 return 0;
}

编译器每次编译一个文件时都会把include的头文件包括进来，所以在编译cpp1时，会定义一个print的函数；在编译main时，又定义一个print的函数，其实这时还没有产生错误。当我们链接这两个编译后的文件之后，才产生了多次定义错误。根据下图也能看到是链接器报错。

为什么fun函数没有报错？
因为在main里我是声明了fun函数，在编译时编译器就知道别处有这样一个函数，在链接的时候看到cpp1里定义了fun函数，于是把main的fun符号重定位到cpp1的fun函数，所以最后调用的是cpp1定义的fun函数（这里链接时链接器是如何做的我不是很清楚）

头文件被包含多次时tips:

1. 用const修饰的变量会默认对其他cpp文件不可见，所以在头文件里定义了const int a = 1并多次包含这个头文件不会保错。
2. 对于类来说，似乎写在头文件class x{};括号里的内容都不产生这种错误。如下：

#ifndef HEADER_H
#define HEADER_H

#include <iostream>
#include <string>
using namespace std;
class A {
    void print(){} //no error
};
#endif

如果定义在类外同时在头文件中，会产生错误。如下：

#ifndef HEADER_H
#define HEADER_H

#include <iostream>
#include <string>
using namespace std;
class A {
    void print();
};
void A::print(){} //error
#endif