Remove more superfluous semicolons after function definition

Author: Rageking8

docs/atl/codesnippet/CPP/atl-collection-classes_1.cpp

@@ -29,7 +29,7 @@ class MyTraits : public CElementTraits< MyData >
          return true;
       else
          return false;
-   };
+   }
 };
 
 void DoAtlCustomTraitsList()

docs/c-runtime-library/reference/get-purecall-handler-set-purecall-handler.md

@@ -64,7 +64,7 @@ class CDerived;
 class CBase
 {
 public:
-   CBase(CDerived *derived): m_pDerived(derived) {};
+   CBase(CDerived *derived): m_pDerived(derived) {}
    ~CBase();
    virtual void function(void) = 0;
 
@@ -74,8 +74,8 @@ public:
 class CDerived : public CBase
 {
 public:
-   CDerived() : CBase(this) {};   // C4355
-   virtual void function(void) {};
+   CDerived() : CBase(this) {}   // C4355
+   virtual void function(void) {}
 };
 
 CBase::~CBase()

docs/code-quality/c28208.md

@@ -30,8 +30,8 @@ typedef void test_type(void*);
 #include "c28208_example.h"
 test_type my_test1;
 test_type my_test2;
-void my_test1(int* x){};  // Generates C28208
-void my_test2(void* x){};  // Doesn't generate C28208
+void my_test1(int* x){}  // Generates C28208
+void my_test2(void* x){}  // Doesn't generate C28208
 
 int main()
 {

docs/cpp/class-templates.md

@@ -28,15 +28,15 @@ public:
 
 template< class T, int i > MyStack< T, i >::MyStack( void )
 {
-};
+}
 
 template< class T, int i > void MyStack< T, i >::push( const T item )
 {
-};
+}
 
 template< class T, int i > T& MyStack< T, i >::pop( void )
 {
-};
+}
 
 int main()
 {

docs/cpp/decltype-cpp.md

@@ -60,7 +60,7 @@ In C++11, you can use the **`decltype`** type specifier on a trailing return typ
 
 ```cpp
 template<typename T, typename U>
-UNKNOWN func(T&& t, U&& u){ return t + u; };
+UNKNOWN func(T&& t, U&& u){ return t + u; }
 ```
 
 The introduction of the **`decltype`** type specifier enables a developer to obtain the type of the expression that the function template returns. Use the *alternative function declaration syntax* that is shown later, the **`auto`** keyword, and the **`decltype`** type specifier to declare a *late-specified* return type. The late-specified return type is determined when the declaration is compiled, instead of when it's coded.
@@ -75,12 +75,12 @@ In the following code example, the late-specified return type of the `myFunc` fu
 //C++11
 template<typename T, typename U>
 auto myFunc(T&& t, U&& u) -> decltype (forward<T>(t) + forward<U>(u))
-        { return forward<T>(t) + forward<U>(u); };
+        { return forward<T>(t) + forward<U>(u); }
 
 //C++14
 template<typename T, typename U>
 decltype(auto) myFunc(T&& t, U&& u)
-        { return forward<T>(t) + forward<U>(u); };
+        { return forward<T>(t) + forward<U>(u); }
 ```
 
 ## `decltype` and forwarding functions (C++11)

docs/cpp/explicit-specialization-of-function-templates.md

@@ -21,7 +21,7 @@ This declaration enables you to define a different function for **`double`** var
 // explicit_specialization.cpp
 template<class T> void f(T t)
 {
-};
+}
 
 // Explicit specialization of f with 'char' with the
 // template argument explicitly specified:

docs/cpp/explicitly-defaulted-and-deleted-functions.md

@@ -44,7 +44,7 @@ These rules can complicate the implementation of what should be straight-forward
 ```cpp
 struct noncopyable
 {
-  noncopyable() {};
+  noncopyable() {}
 
 private:
   noncopyable(const noncopyable&);

docs/cpp/initializers.md

@@ -51,8 +51,8 @@ Initializers may take these forms:
     };
     class PointConsumer{
     public:
-        void set_point(Point p){};
-        void set_points(initializer_list<Point> my_list){};
+        void set_point(Point p){}
+        void set_points(initializer_list<Point> my_list){}
     };
     int main() {
         PointConsumer pc{};

docs/cpp/safebuffers.md

@@ -50,7 +50,7 @@ static int checkBuffers() {
     BUFFER cb;
     // Use the buffer...
     return 0;
-};
+}
 static __declspec(safebuffers)
     int noCheckBuffers() {
     BUFFER ncb;

docs/cpp/selectany.md

@@ -56,7 +56,7 @@ extern __declspec(selectany) int x5;
 // OK: dynamic initialization of global object
 class X {
 public:
-X(int i){i++;};
+X(int i){i++;}
 int i;
 };