implement_functions.txt

============================================
def_constructor
============================================
class C 
{
    public:
    C();
};
-----------------------------
C::C()
{
}
----------------------------
4,4

============================================
destructor
============================================
class C 
{
    public:
    ~C();
};
-----------------------------
C::~C()
{
}
----------------------------
4,4

============================================
copy_constructor
============================================
class C 
{
    public:
    C(const C&);
};
-----------------------------
C::C(const C&)
{
}
----------------------------
4,4

============================================
copy_assignment
============================================
class C 
{
    public:
    C& operator=(const C&);
};
-----------------------------
C& C::operator=(const C&)
{
}
----------------------------
4,4

===========================================
with_return_type
===========================================
class C 
{
public:
    void test();
};
-------------------------------------
void C::test()
{
}
-------------------------------------
4, 4

===========================================
with_return_type_and_args
===========================================
class C 
{
public:
    void test(int i);
};
-------------------------------------
void C::test(int i)
{
}
-------------------------------------
4, 4

=================================
with_ref_return_type_and_args
===============================
#include <vector>
class C 
{
public:
    std::vector<int>& test(int i);
};
-------------------------
std::vector<int>& C::test(int i)
{
}

----------------------------
5,5

====================================
default_value
=================================
#include <vector>
class C 
{
public:
    std::vector<int>& test(int i = 1);
};
------------------------------
std::vector<int>& C::test(int i)
{
}

-----------------------------
5,5

============================================
const_func_const_reference_return
============================================
#include <vector>
class C 
{
    public:
    const std::vector<int>& j() const;
};
-----------------------------
const std::vector<int>& C::j() const
{
}
----------------------------
5,5

============================================
const_func_const_reference_return_override
============================================
#include <vector>
class A
{
public:
    virtual const std::vector<int>& j() const = 0;
};
class C : public A
{
public:
    const std::vector<int>& j() const override;
};
-----------------------------
const std::vector<int>& C::j() const
{
}
----------------------------
10,10

============================================
class_template
============================================
#include <vector>
template<typename T, typename J>
class C 
{
    public:
    const std::vector<int>& j() const;
};
-----------------------------
template <typename T, typename J>
const std::vector<int>& C<T,J>::j() const
{
}
----------------------------
6,6

============================================
class_template_function_template
============================================
#include <vector>
template<typename T, typename J>
class C 
{
    public:
    template<typename H, typename K>
    const std::vector<int>& j(K l, H f) const;
};
-----------------------------
template <typename T, typename J> template <typename H, typename K>
const std::vector<int>& C<T,J>::j(K l, H f) const
{
}
----------------------------
7,7

============================================
class_template_function_template_with_default_values
============================================
#include <vector>
template<typename T, typename J = C>
class C 
{
    public:
    template<typename H, typename K = Z>
    const std::vector<int>& j(K l, H f) const;
};
-----------------------------
template <typename T, typename J> template <typename H, typename K>
const std::vector<int>& C<T,J>::j(K l, H f) const
{
}
----------------------------
7,7

============================================
normal_nested_class
============================================
class C 
{
public:
    class J
    {
    public:
        void test();
    };
};
-----------------------------
void C::J::test()
{
}
----------------------------
7, 7


============================================
template_nested_class_tempalte_class
============================================
template<typename T>
class C 
{
public:
    template<typename K>
    class J
    {
    public:
        void test();
    };
};
-----------------------------
template <typename T> template <typename K>
void C<T>::J<K>::test()
{
}
----------------------------
9, 9


============================================
template_nested_class_tempalte_class_template_fun
============================================
template<typename T>
class C 
{
public:
    template<typename K>
    class J
    {
    public:
        template<typename S>
        void test(S s);
    };
};
-----------------------------
template <typename T> template <typename K> template <typename S>
void C<T>::J<K>::test(S s)
{
}
----------------------------
10, 10


============================================
template_nested_class_template_class_template_fun_with_normal
============================================
template<typename T>
class C 
{
public:
    template<typename K>
    class J
    {
    public:
        template<typename S>
        void test(S s);
        void test2();
    };
    void test4();
};
-----------------------------
template <typename T> template <typename K> template <typename S>
void C<T>::J<K>::test(S s)
{
}
template <typename T> template <typename K>
void C<T>::J<K>::test2()
{
}
template <typename T>
void C<T>::test4()
{
}

----------------------------
1, 14

============================================
nested_class_template_class_with_constructor
============================================
template<typename T>
class C 
{
public:
    class J
    {
    public:
        void J(T s);
        void test2();
    };
    void test4();
};
-----------------------------
template <typename T>
void C<T>::J::J(T s)
{
}

----------------------------
8,8 

============================================
nested_template_class_class_with_constructor
============================================
class C 
{
public:
    template<typename T>
    class J
    {
    public:
        void J(T s);
        void test2();
    };
    void test4();
};
-----------------------------
template <typename T>
void C::J<T>::J(T s)
{
}

----------------------------
8,8 

============================================
variable_with_functions
============================================
class C 
{
public:
    void test();
    int& test2();
private:
    int a;
    int& b;
};
-----------------------------
void C::test()
{
}
int& C::test2()
{
}
----------------------------
1,9

============================================
variable_with_functions_templates
============================================
template<typename T>
class C 
{
public:
    void test();
    int& test2();
private:
    int a;
    T& b;
};
-----------------------------
template <typename T>
void C<T>::test()
{
}
template <typename T>
int& C<T>::test2()
{
}
----------------------------
1,10

============================================
pointer_return
============================================
class C 
{
public:
    int* test2();
};
-----------------------------
int* C::test2()
{
}
----------------------------
4,4


============================================
pointer_return_template_class
============================================
template<typename T>
class C 
{
public:
    int* test2();
};
-----------------------------
template <typename T>
int* C<T>::test2()
{
}
----------------------------
5,5


============================================
pointer_return_template_function
============================================
class C 
{
public:
    template<typename T>
    int* test2();
};
-----------------------------
template <typename T>
int* C::test2()
{
}
----------------------------
5,5


============================================
vector_pointer_return_template_function
============================================
#include <vector>
class C 
{
public:
    template<typename T>
    std::vector<int>* test2();
};
-----------------------------
template <typename T>
std::vector<int>* C::test2()
{
}
----------------------------
6,6

============================================
noexcept_with_template
============================================
class C 
{
public:
    template<typename T>
    int* test2() noexcept;
};
-----------------------------
template <typename T>
int* C::test2() noexcept
{
}
-----------------------------
5,5

============================================
const_noexcept_with_template
============================================
class C 
{
public:
    template<typename T>
    int* test2() const noexcept;
};
-----------------------------
template <typename T>
int* C::test2() const noexcept
{
}
-----------------------------
5,5

============================================
simple_global_functions
============================================
void test();
-----------------------------
void test()
{
}
-----------------------------
1,1
============================================
global_functions_with_args
============================================
void test(int a, int b, std::vector<int> d);
-----------------------------
void test(int a, int b, std::vector<int> d)
{
}
-----------------------------
1,1
============================================
global_functions_with_args_with_return
============================================
std::map<int, std::string> test(int a, int b, std::vector<int> d);
-----------------------------
std::map<int, std::string> test(int a, int b, std::vector<int> d)
{
}
-----------------------------
1,1
============================================
template_global_functions_with_args
============================================
template<typename T>
void test(int a, int b, std::vector<int> d);
-----------------------------
template <typename T>
void test(int a, int b, std::vector<int> d)
{
}
-----------------------------
1,2
============================================
template_global_functions_with_args_with_return
============================================
template<typename T>
std::map<int, std::string> test(int a, int b, std::vector<int> d);
-----------------------------
template <typename T>
std::map<int, std::string> test(int a, int b, std::vector<int> d)
{
}
-----------------------------
1,2
============================================
template_global_functions
============================================
template<typename T>
void test();
-----------------------------
template <typename T>
void test()
{
}
-----------------------------
1,2
============================================
global_functions_w_header_guard
============================================
#ifndef TEST_H
#define TEST_H
void test();
#endif
-----------------------------
void test()
{
}
-----------------------------
3,3
============================================
global_functions_w_namespace
============================================
namespace t{
void test();
}
-----------------------------
void test()
{
}
-----------------------------
2,2