Setting shortcut for printf in emacs - emacs

Question

I am a beginner in emacs and have become a big fan since I started it. Lately I have been debugging a large code base,and I need to put lots of printf statements to make sense of how the code works.
How can I set shortcut in emacs for writing a printf statement and putting cursor after first double inverted comma, so that i can write my own debug message?

Answer 1

You could use yasnippet (or one of the similar systems)
a printf sinppet would look something like this
# -*- mode: snippet -*-
# name: printf
# key: printf
# --
printf("$0%n");
(if it doesn't already exists I'm not sure what language you are looking for)

Answer 2

I agree with Trudbert that a template system is probably the way to go, since that is exactly the kind of functionality they're aiming to provide. Also, for such a small edit a keyboard macro as recommended in one of the comments is a feasible solution. Still I'd like to add an Emacs Lisp version because (a) for this simple example it's easy enough and (b) it might give you more general insights into how to customize Emacs for other things in the future.
(defun insert-printf ()
(interactive)
(insert "printf(\"\");")
(backward-char 3))
Place the above code in your .emacs file and evaluate it by either
placing the point inside the function and pressing C-M-x to run (eval-defun)
placing the point right after the very last ) and pressing C-x C-e to run (eval-last-sexp)
inside the .emacs buffer type M-x eval-buffer
restart Emacs
After any of these actions, Emacs will now know about the function insert-printf so that you can use it. Let's go through it line-by-line to see what it does.
(defun insert-printf ()
starts a function definition. The name of the function is insert-printf and it takes no arguments, hence the empty ()
(interactive)
this declaration turns the function into a command, meaning that you can invoke it by typing M-x insert-printf. If you didn't include this declaration, the only way you could invoke insert-printf would be from other Lisp code.
(insert "printf(\"\");")
inserts the string printf(""); into the buffer at the current position of the point. Note that we have to quote the " with backslashes.
(backward-char 3))
moves the point three characters to the left. After the insertion of printf(""); the point was located right after the semicolon. Since you want it to be between the double quotes we have to move it left by three characters.
Note that Emacs is single-threaded so you don't have to worry about other threads modifying the point position between the last two lines.
Now, you probably want to bind this function to a keyboard shortcut, so you don't have to type M-x insert-printf every single time. You could do this either globally or for specific modes only. Since printf(); is an expression that only really makes sense in C or C++ code, you will probably be fine with having the shortcut only available in C/C++ buffers.
So, let's put the following code in the .emacs file as well:
(add-hook 'c-initialization-hook
(lambda () (define-key c-mode-base-map "\C-cp" 'insert-printf)))
What this code does is add a callback to Emacs that gets called when cc-mode is first initialized, in which case we define the keyboard shortcut C-c p to invoke our insert-printf function. Note that we define this shortcut specifically inside the keymap c-mode-base-map which serves as the basis from which the keymaps for c-mode and c++-mode inherit. Thus our shortcut will not be available in, say, java-mode.
So now you've seen some general steps for customizing your Emacs:
Define the new functionality in terms of a function
Turn the function into a command by adding the (interactive) declaration
Put the code into your .emacs file so it gets loaded on start-up
Define a keyboard shortcut, either globally or locally in a specific mode
Use initialization hooks or (eval-after-load) to define mode-specific shortcuts only when that mode is actually activated for the first time.

Answer 3

This answer is independent of Emacs, but hopefully someone finds it useful. It's a header that defines some macros that print debug messages on stderr, but more convenient that just a printf(). Obviously you can make snippets or abbrevs or whatever with these too. It might use gcc features that are not available in other compilers.
#ifndef __debug_h__
#define __debug_h__
#include <stdio.h>
#include <errno.h>
#define DEBUG
/* #undef DEBUG */
/* macro that prints (like printf) to stderr, prepending the filename, line number, and function name */
#ifdef DEBUG
#define _DBG(fmt, args...) do { fprintf(stderr, "%s(%u): in func %s: " fmt, __FILE__, __LINE__, __FUNCTION__, ##args); fflush(stderr); } while (0)
#elif
#define _DBG(fmt, args...) do {} while(0)
#endif
/* e.g. DBG("arbitrary string"); */
#define DBG(str) _DBG(str "%s\n", "")
/* e.g. DBGF("formated string ("%s") and int (%d)", "blah", 42); */
#define DBGF(fmt, args...) _DBG(fmt "\n", args)
/* e.g. DBG_VAR("%0x08X", (int)interesting_variable); */
#define DBG_VAR(fmt, x) _DBG("%s = " fmt "\n", #x, x)
#define PERR(str) if (errno) { _DBG("%s", ""); perror(str); fflush(stderr); }
#define DBG_COMPILE_TIMESTAMP(str) _DBG("Compiled on " __DATE__ " at " __TIME__ "%s\n", "")
#endif /* #ifndef __debug_h__ */