Redundant access specifiers should be removed because they needlessly clutter the code.
Noncompliant code example
struct S {
public: // Noncompliant; does not affect any declaration
private:
void f1();
private: // Noncompliant; does not change accessibility level
void f2();
private: // Noncompliant; does not affect any declaration
};
class C {
void f1();
private: // Noncompliant; does not change accessibility level
void f2();
};
Compliant solution
struct S {
private:
void f1();
void f2();
};
class C {
void f1();
void f2();
};
Exceptions
An access specifier at the very beginning of a class or struct that matches the default access level is ignored even when
it doesn’t change any accessibility levels.
class C {
private: // redundant but accepted
// ...
};
struct S {
public: // redundant but accepted
// ...
};
Such a specifier is redundant but ignored to allow classes and structs to be described uniformly.
class C {
public:
void call();
protected:
int delete();
private:
int code;
};
struct S {
public: // redundant but accepted
int sum();
protected:
int min();
private:
int count;
};
Additionally, many people use an access specifier not to change the access level but as a visual separator between member functions and member
variables of a class. This rule does not raise an issue on this pattern:
class C {
public:
void f1();
private:
void f2();
void f3();
private: // redundant but accepted: separates functions from variables
int m1;
}
Finally, Qt meta-object system makes use of some custom (macro-based) access specifiers. Even when they have no impact on the access level of the
following members according to the C++ definition, they are accepted as long as they differ in spelling:
class Counter : public QObject {
Q_OBJECT
public:
Counter() { m_value = 0; }
int value() const { return m_value; }
public slots: // equivalent to "public" but accepted
void setValue(int value);
signals: // equivalent to "public" but accepted
void keyChanged(int newValue);
signals: // Noncompliant; does not change accessibility level
void valueChanged(int newValue);
private:
int m_key;
int m_value;
};
