code stringlengths 1 2.06M | language stringclasses 1
value |
|---|---|
#include <iostream>
using namespace std;
int main()
{
int height;
float eyesight;
height = 175;
eyesight = 0.8f;
bool ok;
ok = height >= 160 && height <=180 &&
eyesight >= 1.0f && eyesight <= 2.0f;
cout << boolalpha;
cout << ok << endl;
return 0;
} | C++ |
int main()
{
int a = 100;
int b = 200;
int c = 300;
return 0;
} | C++ |
#include<iostream>
using namespace std;
void main()
{
int a[10], i;
for(i=0; i<10; i++)
a[i]=i+1;
for(i=0; i<10; i++)
cout << a[i] << " ";
cout <<"\n";
}
| C++ |
/*
* Copyright 2011, Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to... | C++ |
/*
* Copyright 2011, Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to... | C++ |
/*
* Copyright 2011, Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to... | C++ |
/*
* Copyright 2011, Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to... | C++ |
/*
* Copyright 2011, Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to... | C++ |
/*
* Copyright 2011, Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to... | C++ |
/*
* Copyright 2011, Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to... | C++ |
/*
* Copyright 2011, Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to... | C++ |
#ifndef __NONAME_GETPROC_H__
#define __NONAME_GETPROC_H__
#define NONAME_LIB_USE
#include <ntifs.h>
#include "nm_mem.h"
#include "nm_undoc.h"
class kgetproc {
public:
kgetproc(PDRIVER_OBJECT DriverObj) {m_LoadedModuleList = (PLIST_ENTRY)DriverObj->DriverSection;}
PVOID GetSystemRoutineAddress(PUNI... | C++ |
#ifndef __NM_EXCEPTION_H__
#define __NM_EXCEPTION_H__
#define NONAME_LIB_USE
#include <ntifs.h>
#include "nm_mem.h"
class KException
{
public:
static void Install();
NTSTATUS Status() const;
PVOID const At() const;
protected:
KException(EXCEPTION_POINTERS const &info);
static void __cdecl ... | C++ |
#include "nm_hashtable.h"
| C++ |
#include "nm_mem.h"
klookaside::klookaside( ULONG Size, ULONG Tag /*= NM_LOOKASIDE_TAG*/, POOL_TYPE PoolType /*= PagedPool*/ )
: m_PagedLookasideList(NULL), m_NPagedLookasideList(NULL), m_PoolType(PoolType);
{
if (PoolType == NonPagedPool) {
m_NPagedLookasideList = new(NonPagedPool, Tag) NPAGED_LOOKASIDE... | C++ |
#include "nm_workthread.h"
kworkthread::kworkthread() : m_Stop(FALSE), m_Lookaside(sizeof(WORK_ITEM))
{
RtlZeroMemory(&m_ClientId, sizeof(CLIENT_ID));
InitializeListHead(&m_ListHeader);
KeInitializeEvent(&m_InsertEvent, SynchronizationEvent, FALSE);
KeInitializeSpinLock(&m_Lock);
PsCreateSystemThread(&m_T... | C++ |
#ifndef __NONAME_CRICULARQUEUE_H__
#define __NONAME_CRICULARQUEUE_H__
#define NONAME_LIB_USE
#include <ntifs.h>
#include "nm_mem.h"
#define DEFAULT_MAX_CQ_SIZE 64
template <class T>
class cirbuf
{
public:
cirbuf( ULONG Size = DEFAULT_MAX_CQ_SIZE ) : m_Tail(0), m_Head(0), m_ItemCount(0)
{
m_Buffe... | C++ |
#include "nm_list.h"
| C++ |
#include "nm_exception.h"
extern "C" {
typedef void (__cdecl *_se_translator_function)(ULONG ExceptionCode, EXCEPTION_POINTERS* pExceptionPointers);
_se_translator_function __cdecl set_se_translator(_se_translator_function);
}
KException::KException(EXCEPTION_POINTERS const &info)
{
EXCEPTION_RECORD... | C++ |
/*
---------------------------------------------------------------------------
Copyright (c) 2003, Dominik Reichl <[email protected]>, Germany.
All rights reserved.
Distributed under the terms of the GNU General Public License v2.
This software is provided 'as is' with no explicit or implied warr... | C++ |
#include "nm_stack.h"
| C++ |
#ifndef __NONAME_LIST_H__
#define __NONAME_LIST_H__
#define NONAME_LIB_USE
#include <ntifs.h>
#include "nm_mem.h"
typedef BOOLEAN (__stdcall *COMPAREPROC)(PVOID Dst, PVOID Src);
template <class T>
struct _klist_entry {
struct _klist_entry<T> *FLink, *BLink;
T Value;
public:
_klist_entry() {FLink = N... | C++ |
#include "nm_event.h"
NTSTATUS kevent::Create( EVENT_TYPE Type /*= NotificationEvent*/, BOOLEAN InitialState /*= FALSE*/ )
{
NTSTATUS ns;
OBJECT_ATTRIBUTES oa;
m_Event = 0;
InitializeObjectAttributes(&oa,
NULL,
OBJ_KERNEL_HANDLE,
0,
NULL);
ns = ZwCreateEvent(&m_Event,
EVENT_ALL_ACCE... | C++ |
#include "nm_vector.h"
| C++ |
#ifndef __NONAME_STACK_H__
#define __NONAME_STACK_H__
#define NONAME_LIB_USE
#include <ntifs.h>
#define DEFAULT_STACK_SIZE 64
template <class T>
class kstack {
public:
kstack();
kstack(ULONG Size);
void Release();
ULONG Push(const T &Val);
ULONG pop(T &Val);
ULONG GetStackPointer() {return ... | C++ |
#ifndef __NONAME_STRING_H__
#define __NONAME_STRING_H__
#define NONAME_LIB_USE
#include <ntifs.h>
#include "nm_mem.h"
#include <ntstrsafe.h>
class kstringw {
public:
kstringw();
kstringw(PWCHAR String);
kstringw(PUNICODE_STRING UniString);
void Release();
PWCHAR Allocate(ULONG size, BOOLEAN S... | C++ |
#include "nm_cppcrt.h"
#pragma section(".CRT$XCA",long,read)
KCRT_FUNCTION xc_a[] = { 0 };
#pragma section(".CRT$XCZ",long,read)
KCRT_FUNCTION xc_z[] = { 0 };
#pragma data_seg()
#pragma comment(linker, "/merge:.CRT=.data")
AtExitCall* AtExitCall::m_ExitList = 0;
#ifdef __cplusplus
extern "C" {
#en... | C++ |
#include "nm_inlinehook.h"
VOID __stdcall kinlinehook::DpcLock(struct _KDPC *Dpc, PVOID DeferredContext, PVOID SystemArgument1, PVOID SystemArgument2)
{
__asm cli;
InterlockedIncrement(&((PDPCLOCK_CONTEXT)DeferredContext)->Locks);
do {
__asm pause;
} while (!((PDPCLOCK_CONTEXT)DeferredContext)->Relea... | C++ |
#include "nm_file.h"
kfile::kfile()
{
m_filehandle = 0;
m_fileobj = NULL;
}
void kfile::Release()
{
Close();
}
VOID kfile::Close()
{
if (m_fileobj != NULL) {
ObDereferenceObject(m_fileobj);
m_fileobj = NULL;
}
if (m_filehandle != NULL) {
ZwClose(m_filehandle);
m_filehandle = ... | C++ |
#include "nm_crique.h" | C++ |
#ifndef __NONAME_CPPCRT_H__
#define __NONAME_CPPCRT_H__
#define NONAME_LIB_USE
#include <ntifs.h>
#include "nm_mem.h"
extern "C" NTSTATUS __cdecl NM_DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegPath);
typedef void(__cdecl* KCRT_FUNCTION)();
class AtExitCall {
public:
AtExitCall(KCRT_F... | C++ |
#ifndef __NONAME_EVENT_H__
#define __NONAME_EVENT_H__
#define NONAME_LIB_USE
#include <ntifs.h>
class kevent {
public:
kevent() : m_Event(0) {}
NTSTATUS Create(EVENT_TYPE Type = NotificationEvent, BOOLEAN InitialState = FALSE);
NTSTATUS Create(PWCHAR Name, EVENT_TYPE Type = NotificationEvent, BOOLEAN I... | C++ |
#ifndef __NONAME_WORKTHREAD_H__
#define __NONAME_WORKTHREAD_H__
#define NONAME_LIB_USE
#include <ntifs.h>
#include "nm_mem.h"
typedef VOID (__stdcall *WORKITEMPROC)(PVOID Context);
class kworkthread
{
public:
kworkthread();
void Release();
VOID InsertItem(WORKITEMPROC Address, PVOID Context, PRK... | C++ |
#ifndef __NONAME_MEMORY_H__
#define __NONAME_MEMORY_H__
#include <ntifs.h>
#include "nm_undoc.h"
#ifndef NONAME_MEM_TAG
#define NONAME_MEM_TAG 'nonm'
#endif
#ifndef NONAME_MEM_TYPE
#define NONAME_MEM_TYPE PagedPool
#endif
#ifdef NONAME_LIB_USE
#define NONAME_INTER_MEM_TYPE NONAME_MEM_TYPE
#else
... | C++ |
#include "nm_getproc.h"
PVOID kgetproc::FindExportedRoutineByName(PVOID DllBase, PANSI_STRING AnsiImageRoutineName )
{
USHORT OrdinalNumber;
PULONG NameTableBase;
PUSHORT NameOrdinalTableBase;
PULONG Addr;
LONG High;
LONG Low;
LONG Middle;
LONG Result;
ULONG ExportSize;
PVOID FunctionAddress;
... | C++ |
#ifndef __NONAME_HASHTABLE_H__
#define __NONAME_HASHTABLE_H__
#define NONAME_LIB_USE
#include <ntifs.h>
#include "nm_mem.h"
#include "algo/crc32.h"
#define HASH_DEFAULT_CAP 128
template< class VAL >
class khashtable {
public:
BOOLEAN Init( ULONG Size = HASH_DEFAULT_CAP );
BOOLEAN Resize( ULONG Si... | C++ |
#ifndef __NONAME_FILE_H__
#define __NONAME_FILE_H__
#define NONAME_LIB_USE
#include <Ntifs.h>
#include "nm_mem.h"
#include "nm_string.h"
#define FILE_BEGIN 0
#define FILE_CURRENT 1
#define FILE_END 2
class kfile {
public:
kfile();
void Release();
VOID Close();
NTSTATUS Create(
kstring... | C++ |
#include "nm_dir.h"
kdirectory::kdirectory()
{
m_filehandle = 0;
m_fileobj = NULL;
}
void kdirectory::Release()
{
Close();
}
VOID kdirectory::Close()
{
if (m_fileobj != NULL) {
ObDereferenceObject(m_fileobj);
m_fileobj = NULL;
}
if (m_filehandle != NULL) {
ZwClose(m_filehandle);... | C++ |
#ifndef __NONAME_INLINE_HOOK_H__
#define __NONAME_INLINE_HOOK_H__
#define NONAME_LIB_USE
#include <ntifs.h>
#include "nm_mem.h"
#include "disasm/LDasm.h"
typedef BOOLEAN (__stdcall *HOOKPROC)(PVOID Context);
typedef struct _DPCLOCK_CONTEXT {
PKDPC Dpcs;
LONG Locks;
BOOLEAN Release;
_DPCLOCK_C... | C++ |
#ifndef __NONAME_VECTOR_H__
#define __NONAME_VECTOR_H__
#define NONAME_LIB_USE
#include <ntifs.h>
#include "nm_mem.h"
#define DEFAULT_INIT_VECTOR 32
template <class T>
class kvector {
public:
kvector();
kvector(ULONG Size, ULONG Step);
void Release();
ULONG Size() { return m_ItemCount; }
T& ... | C++ |
#include "nm_string.h"
kstringw::kstringw()
{
m_stringw = NULL;
m_len = 0;
}
kstringw::kstringw( PWCHAR String )
{
ULONG Size;
Size = wcslen(String);
m_stringw = Allocate(Size, FALSE);
RtlStringCchCopyW(m_stringw, Size, String);
m_len = Size;
}
kstringw::kstringw( PUNICODE_STRING UniStrin... | C++ |
#ifndef __NONAME_DIR_H__
#define __NONAME_DIR_H__
#define NONAME_LIB_USE
#include <ntifs.h>
#include "nm_mem.h"
#include "nm_string.h"
class kdirectory {
public:
kdirectory();
void Release();
VOID Close();
NTSTATUS Create(
kstringw& FileName,
ULONG CreateDisposition = FILE_OPEN,
ACCE... | C++ |
#include "Skin.h"
Skin::Skin(QString name, QString extension, QString path) {
this->name = name;
this->extension = extension;
this->path = path;
}
/**
* Create a skin instance from a path (must have at least a valid info.ini file)
*/
Skin* Skin::fromPath(QString path) {
// Checking the ini file... | C++ |
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
namespace Ui {
class MainWindow;
}
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();
private:
Ui::MainWindow *ui;
};
#endif // MAINWINDOW_H
| C++ |
#include "MainWindow.h"
#include "ui_MainWindow.h"
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
}
MainWindow::~MainWindow()
{
delete ui;
}
| C++ |
#ifndef SKIN_H
#define SKIN_H
#include "includes.h"
/**
* Proxy class to handle card skins. Allows to:
* - Skins listing with proper names
* - Skins "loading" (only loads name, properties and path)
* - Proxying each card file path: skin path if it exists, default path else
*/
class Skin : public QOb... | C++ |
#ifndef PROPERTIES_H
#define PROPERTIES_H
#include <QString>
class Properties {
public:
// Application
static const QString ORGANIZATION;
static const QString APPLICATION;
static const QString SETTINGS;
// Networking
static const quint16 DEFAULT_LISTENPORT;
// Cards informations
... | C++ |
#ifndef CARDINFO_H
#define CARDINFO_H
#include "includes.h"
class CardInfo : public QObject {
Q_OBJECT
public:
/* Function of the card: Distance, hazard, remedy or safety */
enum FunctionType {
Function_NoFunction, // NoCard
Function_Distance,
Function_Hazard,
Function_Remedy,
Functi... | C++ |
#include "Tableau.h"
Tableau::Tableau(Team* owningTeam) {
this->owningTeam = owningTeam;
this->winDistance = 1000; // Let's say default value. Can be set/"extended" during gameplay
}
Tableau::~Tableau() {
this->owningTeam = NULL;
}
/**
* The number of 200km already played.
*/
int Tableau::nu... | C++ |
#ifndef DISCARDPILE_H
#define DISCARDPILE_H
#include "includes.h"
#include "Card.h"
class DiscardPile : public QList<CardID> {
public:
explicit DiscardPile();
};
#endif // DISCARDPILE_H
| C++ |
#include "RaceInfo.h"
RaceInfo::RaceInfo() {
this->numberOfCards = 0;
this->extension = false;
this->extensionAllowed = false;
this->normalDistance = 1000;
this->extensionDistance = 1000;
}
RaceInfo::RaceInfo(int numberOfCard, bool extension, bool extensionAllowed, int normalDistance, int extensionDist... | C++ |
#include "DiscardPile.h"
DiscardPile::DiscardPile() {}
| C++ |
#include "Card.h"
QHash<CardID,CardInfo*>* Card::infoHash = NULL;
Card::Card() {}
CardInfo* Card::getInfo(CardID id) {
// Ensures a singleton hash AND that the hash is filled before reading it.
if (infoHash == NULL) createInfoHash();
return infoHash->value(id);
}
CardID Card::cardForPropert... | C++ |
#ifndef PLAYER_H
#define PLAYER_H
#include "includes.h"
#include "Hand.h"
class Player {
public:
explicit Player(QString name);
QString getName() const;
Hand getHand() const;
private:
QString name;
Hand hand;
};
#endif // PLAYER_H
| C++ |
#include "DrawPile.h"
DrawPile::DrawPile() {}
| C++ |
#ifndef CARD_H
#define CARD_H
#include "includes.h"
#include "CardInfo.h"
class Card : public QObject {
Q_OBJECT
public:
/* Card unique IDs */
enum ID {
CardID_NoCard,
CardID_Distance_25,
CardID_Distance_50,
CardID_Distance_75,
CardID_Distance_100,
CardID_Distance_200,
... | C++ |
#include "CardInfo.h"
CardInfo::CardInfo(QString name, QString filename, CardFunction function, CardNature nature, int distance) {
this->name = name;
this->filename = filename;
this->function = function;
this->nature = nature;
this->distance = distance;
}
QString CardInfo::getName() const {
return ... | C++ |
#ifndef RACEINFO_H
#define RACEINFO_H
#include "includes.h"
class RaceInfo : public QObject {
Q_OBJECT
public:
RaceInfo();
RaceInfo(int numberOfCard, bool extension, bool extensionAllowed, int normalDistance, int extensionDistance);
public:
int numberOfCards;
bool extension;
bool extensionAll... | C++ |
#ifndef TEAM_H
#define TEAM_H
#include "includes.h"
#include "Player.h"
#include "Tableau.h"
class Tableau;
class Player;
class Team : public QList<Player*> {
public:
Team();
~Team();
Tableau* getTableau();
void addPlayer(Player* player);
private:
Tableau* tableau;
};
#end... | C++ |
#include "Hand.h"
Hand::Hand() {}
| C++ |
#ifndef TABLEAU_H
#define TABLEAU_H
#include "includes.h"
#include "Team.h"
#include "Player.h"
#include "Card.h"
#include "CardInfo.h"
class Team;
/*$this->pileVitesse = array();
$this->pileCombat = array();
$this->pile200 = array();
$this->pile100 = array();
$this->pile75 = array();
$... | C++ |
#ifndef HAND_H
#define HAND_H
#include "includes.h"
#include "Card.h"
class Hand : public QList<CardID> {
public:
explicit Hand();
private:
};
#endif // HAND_H
| C++ |
#include "Player.h"
Player::Player(QString name) {
this->name = name;
}
QString Player::getName() const {
return name;
}
Hand Player::getHand() const {
return hand;
}
| C++ |
#include "Team.h"
Team::Team() {
tableau = new Tableau(this);
}
Team::~Team() {
// Deleting players and tableau
qDebug() << "~Team()";
for (int i=0; i<size(); i++) {
delete this->at(i);
}
//foreach(Player* player, this) {
// delete player;
//}
delete tableau;
}
Tableau* Team... | C++ |
#ifndef DRAWPILE_H
#define DRAWPILE_H
#include "includes.h"
#include "Card.h"
class DrawPile : public QList<CardID> {
public:
explicit DrawPile();
};
#endif // DRAWPILE_H
| C++ |
#include <QtGui/QApplication>
#include "includes.h"
#include "Tableau.h"
#include "CardInfo.h"
#include "Skin.h"
#include "MainWindow.h"
#include "RaceInfo.h"
int main(int argc, char *argv[]) {
QApplication a(argc, argv);
MainWindow w;
w.show();
/*
RaceInfo info;
qDebug() << inf... | C++ |
#include "Properties.h"
// Application
const QString Properties::ORGANIZATION = "SGC";
const QString Properties::APPLICATION = "1000 Bornes";
const QString Properties::SETTINGS = "settings.ini";
// Networking
const quint16 Properties::DEFAULT_LISTENPORT = 1313;
// Cards informations
const QString Pr... | C++ |
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MP... | C++ |
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MP... | C++ |
End of preview. Expand in Data Studio
Cpp-Code-Large
Cpp-Code-Large is a large-scale corpus of C++ source code comprising more than 5 million lines of C++ code. The dataset is designed to support research in large language model (LLM) pretraining, code intelligence, software engineering automation, and static program analysis for the C++ ecosystem.
By providing a high-volume, language-specific corpus, Cpp-Code-Large enables systematic experimentation in C++-focused model training, domain adaptation, and downstream code understanding tasks.
Cpp-Code-Large addresses the need for a dedicated C++-only dataset at substantial scale, enabling focused research across systems programming, performance-critical applications, embedded systems, game engines, and large-scale native software projects.
1. Dataset Composition
Programming Language: C++
Total Size: 5M+ lines of C++ code
File Format: .jsonl
Primary Content: C++ source and header files (.cpp, .cc, .cxx, .hpp, .h)
Content Types
The dataset includes a wide variety of C++ constructs and paradigms, such as:
Core Language Features
Functions and function overloading
Templates (function and class templates)
Lambda expressions
Namespaces
Macros and preprocessor directives
Inline functions
Header/source separation patterns
Object-Oriented Programming
Classes and structs
Inheritance (single and multiple)
Polymorphism and virtual functions
Abstract base classes
Encapsulation patterns
Operator overloading
Modern C++ (C++11/14/17/20) Features
Smart pointers (unique_ptr, shared_ptr, weak_ptr)
Move semantics and rvalue references
Auto keyword and type inference
constexpr and consteval usage
Structured bindings
Memory and Resource Management
RAII patterns
Manual memory management (new / delete)
Custom allocators
Smart pointer ownership patterns
Exception-safe resource handling
Standard Template Library (STL)
Containers (vector, map, unordered_map, set, etc.)
Iterators and algorithms
Functional utilities
Threading primitives (std::thread, mutex, condition_variable)
Filesystem library
Chrono utilities
Concurrency and Parallelism
Multithreading patterns
Synchronization primitives
Lock-free patterns (where applicable)
Async programming
Thread pools
Systems and Low-Level Programming
File I/O
Socket programming
OS-level interactions
Embedded-style programming patterns
Performance optimization techniques
Build and Project Structures
CMake-based project structures
Modular header organization
Static and dynamic library patterns
Cross-platform compatibility patterns
2. Intended Research Applications
2.1 Pretraining
Training C++ code foundation models from scratch
Continued pretraining of existing LLMs
C++-specialized language modeling
Tokenizer training for C++ ecosystems
Domain adaptation for systems-level models
2.2 Fine-Tuning and Adaptation
Code completion systems
Intelligent IDE assistants
Automated refactoring tools
Conversational programming agents
C++-specific copilots
Static analyzer enhancement models
Performance optimization assistants
2.3 Code Intelligence Tasks
Code summarization
Code-to-text generation
Documentation generation
Bug detection
Security vulnerability detection
Clone detection
Code similarity modeling
Dead code detection
Complexity estimation
Static and structural analysis
Legacy-to-modern C++ migration modeling (e.g., raw pointers → smart pointers)
2.4 Software Engineering Research
Empirical studies of C++ coding patterns
Analysis of architectural styles in native applications
STL and template usage studies
Memory management strategy analysis
Concurrency pattern modeling
AST-based experimentation
Cross-version C++ evolution analysis
Security practice analysis in performance-critical systems
3. Ecosystem Coverage
C++-Code-Large spans a broad range of C++ application domains, including:
Systems software
Embedded systems
Scientific and numerical computing
Desktop applications
Cross-platform libraries
Networking applications
CLI tools
Microservices written in C++
The dataset captures both legacy C++ (pre-C++11 style) and modern C++ (C++11/14/17/20) development patterns, enabling cross-era research and modernization studies.
Thanks to open source community for all the guidance & support!!
- Downloads last month
- 717