CWE-1055: Multiple Inheritance from Concrete Classes
The product contains a class with inheritance from more than one concrete class.
CWE Reference
CWE Weaknesses - Page 16
Browse cwe weaknesses with official CWE context and Glexia analysis.
Release 4.20listing
Search And Filters
Browse CWE records
Showing 50 of 969 CWE records · Page 16 of 20.
CWE-1056: Invokable Control Element with Variadic Parameters
A named-callable or method control element has a signature that supports a variable (variadic) number of parameters or arguments.
CWE-1057: Data Access Operations Outside of Expected Data Manager Component
The product uses a dedicated, central data manager component as required by design, but it contains code that performs data-access operations that do not use this data manager.
CWE-1058: Invokable Control Element in Multi-Thread Context with non-Final Static Storable or Member Element
The code contains a function or method that operates in a multi-threaded environment but owns an unsafe non-final static storable or member data element.
CWE-1059: Insufficient Technical Documentation
The product does not contain sufficient technical or engineering documentation (whether on paper or in electronic form) that contains descriptions of all the relevant software/hardware elements of the product, such as its usage, structure, architectural components, interfaces, design, implementation, configuration, operation, etc.
CWE-1060: Excessive Number of Inefficient Server-Side Data Accesses
The product performs too many data queries without using efficient data processing functionality such as stored procedures.
CWE-1061: Insufficient Encapsulation
The product does not sufficiently hide the internal representation and implementation details of data or methods, which might allow external components or modules to modify data unexpectedly, invoke unexpected functionality, or introduce dependencies that the programmer did not intend.
CWE-1062: Parent Class with References to Child Class
The code has a parent class that contains references to a child class, its methods, or its members.
CWE-1063: Creation of Class Instance within a Static Code Block
A static code block creates an instance of a class.
CWE-1064: Invokable Control Element with Signature Containing an Excessive Number of Parameters
The product contains a function, subroutine, or method whose signature has an unnecessarily large number of parameters/arguments.
CWE-1065: Runtime Resource Management Control Element in a Component Built to Run on Application Servers
The product uses deployed components from application servers, but it also uses low-level functions/methods for management of resources, instead of the API provided by the application server.
CWE-1066: Missing Serialization Control Element
The product contains a serializable data element that does not have an associated serialization method.
CWE-1067: Excessive Execution of Sequential Searches of Data Resource
The product contains a data query against an SQL table or view that is configured in a way that does not utilize an index and may cause sequential searches to be performed.
CWE-1068: Inconsistency Between Implementation and Documented Design
The implementation of the product is not consistent with the design as described within the relevant documentation.
CWE-1069: Empty Exception Block
An invokable code block contains an exception handling block that does not contain any code, i.e. is empty.
CWE-1070: Serializable Data Element Containing non-Serializable Item Elements
The product contains a serializable, storable data element such as a field or member, but the data element contains member elements that are not serializable.
CWE-1071: Empty Code Block
The source code contains a block that does not contain any code, i.e., the block is empty.
CWE-1072: Data Resource Access without Use of Connection Pooling
The product accesses a data resource through a database without using a connection pooling capability.
CWE-1073: Non-SQL Invokable Control Element with Excessive Number of Data Resource Accesses
The product contains a client with a function or method that contains a large number of data accesses/queries that are sent through a data manager, i.e., does not use efficient database capabilities.
CWE-1074: Class with Excessively Deep Inheritance
A class has an inheritance level that is too high, i.e., it has a large number of parent classes.
CWE-1075: Unconditional Control Flow Transfer outside of Switch Block
The product performs unconditional control transfer (such as a "goto") in code outside of a branching structure such as a switch block.
CWE-1076: Insufficient Adherence to Expected Conventions
The product's architecture, source code, design, documentation, or other artifact does not follow required conventions.
CWE-1077: Floating Point Comparison with Incorrect Operator
The code performs a comparison such as an equality test between two float (floating point) values, but it uses comparison operators that do not account for the possibility of loss of precision.
CWE-1078: Inappropriate Source Code Style or Formatting
The source code does not follow desired style or formatting for indentation, white space, comments, etc.
CWE-1079: Parent Class without Virtual Destructor Method
A parent class contains one or more child classes, but the parent class does not have a virtual destructor method.
CWE-1080: Source Code File with Excessive Number of Lines of Code
A source code file has too many lines of code.
CWE-1082: Class Instance Self Destruction Control Element
The code contains a class instance that calls the method or function to delete or destroy itself.
CWE-1083: Data Access from Outside Expected Data Manager Component
The product is intended to manage data access through a particular data manager component such as a relational or non-SQL database, but it contains code that performs data access operations without using that component.
CWE-1084: Invokable Control Element with Excessive File or Data Access Operations
A function or method contains too many operations that utilize a data manager or file resource.
CWE-1085: Invokable Control Element with Excessive Volume of Commented-out Code
A function, method, procedure, etc. contains an excessive amount of code that has been commented out within its body.
CWE-1086: Class with Excessive Number of Child Classes
A class contains an unnecessarily large number of children.
CWE-1087: Class with Virtual Method without a Virtual Destructor
A class contains a virtual method, but the method does not have an associated virtual destructor.
CWE-1088: Synchronous Access of Remote Resource without Timeout
The code has a synchronous call to a remote resource, but there is no timeout for the call, or the timeout is set to infinite.
CWE-1089: Large Data Table with Excessive Number of Indices
The product uses a large data table that contains an excessively large number of indices.
CWE-1090: Method Containing Access of a Member Element from Another Class
A method for a class performs an operation that directly accesses a member element from another class.
CWE-1091: Use of Object without Invoking Destructor Method
The product contains a method that accesses an object but does not later invoke the element's associated finalize/destructor method.
CWE-1092: Use of Same Invokable Control Element in Multiple Architectural Layers
The product uses the same control element across multiple architectural layers.
CWE-1093: Excessively Complex Data Representation
The product uses an unnecessarily complex internal representation for its data structures or interrelationships between those structures.
CWE-1094: Excessive Index Range Scan for a Data Resource
The product contains an index range scan for a large data table, but the scan can cover a large number of rows.
CWE-1095: Loop Condition Value Update within the Loop
The product uses a loop with a control flow condition based on a value that is updated within the body of the loop.
CWE-1096: Singleton Class Instance Creation without Proper Locking or Synchronization
The product implements a Singleton design pattern but does not use appropriate locking or other synchronization mechanism to ensure that the singleton class is only instantiated once.
CWE-1097: Persistent Storable Data Element without Associated Comparison Control Element
The product uses a storable data element that does not have all of the associated functions or methods that are necessary to support comparison.
CWE-1098: Data Element containing Pointer Item without Proper Copy Control Element
The code contains a data element with a pointer that does not have an associated copy or constructor method.
CWE-1099: Inconsistent Naming Conventions for Identifiers
The product's code, documentation, or other artifacts do not consistently use the same naming conventions for variables, callables, groups of related callables, I/O capabilities, data types, file names, or similar types of elements.
CWE-1100: Insufficient Isolation of System-Dependent Functions
The product or code does not isolate system-dependent functionality into separate standalone modules.
CWE-1101: Reliance on Runtime Component in Generated Code
The product uses automatically-generated code that cannot be executed without a specific runtime support component.
CWE-1102: Reliance on Machine-Dependent Data Representation
The code uses a data representation that relies on low-level data representation or constructs that may vary across different processors, physical machines, OSes, or other physical components.
CWE-1103: Use of Platform-Dependent Third Party Components
The product relies on third-party components that do not provide equivalent functionality across all desirable platforms.
CWE-1104: Use of Unmaintained Third Party Components
The product relies on third-party components that are not actively supported or maintained by the original developer or a trusted proxy for the original developer.
CWE-1105: Insufficient Encapsulation of Machine-Dependent Functionality
The product or code uses machine-dependent functionality, but it does not sufficiently encapsulate or isolate this functionality from the rest of the code.